@nexa-stack/framework 1.0.0

package/packages/database/src/database.ts

@@ -0,0 +1,252 @@
+import type { ResourceDefinition } from "../../core/src/resource.js";
+import { SqliteDriver, searchFieldsFor } from "./sqlite.js";
+import { PostgresDriver } from "./postgres.js";
+import { MysqlDriver } from "./mysql.js";
+import type { QueryOpts, PaginatedResult } from "./query.js";
+import { paginate, safeIdent } from "./query.js";
+import type { DatabaseDriver, DbRow, DbDialect } from "./types.js";
+import { QueryBuilder } from "./builder.js";
+import {
+  fieldColumn,
+  foreignKeyFor,
+  isStoredField,
+  pivotTableFor,
+  type FieldDef,
+} from "../../core/src/fields.js";
+import { sqlType, pgSqlType, mySqlType } from "./types.js";
+
+function detectDialect(connection: string): DbDialect {
+  if (connection.startsWith("postgres://") || connection.startsWith("postgresql://")) {
+    return "postgres";
+  }
+  if (connection.startsWith("mysql://") || connection.startsWith("mariadb://")) {
+    return "mysql";
+  }
+  return "sqlite";
+}
+
+export class Database {
+  private driver: DatabaseDriver;
+
+  constructor(connection: string) {
+    const dialect = detectDialect(connection);
+    if (dialect === "postgres") {
+      this.driver = new PostgresDriver(connection);
+    } else if (dialect === "mysql") {
+      this.driver = new MysqlDriver(connection);
+    } else {
+      this.driver = new SqliteDriver(connection);
+    }
+  }
+
+  get dialect(): DbDialect {
+    return this.driver.dialect;
+  }
+
+  async connect(): Promise<void> {
+    await this.driver.connect();
+  }
+
+  from(table: string): QueryBuilder {
+    return new QueryBuilder(this, table);
+  }
+
+  table(table: string): QueryBuilder {
+    return this.from(table);
+  }
+
+  async transaction<T>(fn: (tx: Database) => Promise<T>): Promise<T> {
+    await this.run("BEGIN");
+    try {
+      const result = await fn(this);
+      await this.run("COMMIT");
+      return result;
+    } catch (e) {
+      try {
+        await this.run("ROLLBACK");
+      } catch {
+        /* ignore */
+      }
+      throw e;
+    }
+  }
+
+  async createTable(resource: ResourceDefinition): Promise<void> {
+    await this.driver.createTable(resource);
+    await this.ensurePivotTables(resource);
+    await this.syncColumns(resource);
+  }
+
+  /** Add any missing columns defined on the resource */
+  async syncColumns(resource: ResourceDefinition): Promise<void> {
+    const existing = await this.listColumns(resource.table);
+    const existingSet = new Set(existing.map((c) => c.toLowerCase()));
+
+    for (const [name, field] of Object.entries(resource.fields)) {
+      if (!isStoredField(field)) continue;
+      const col = fieldColumn(name, field);
+      if (!col || existingSet.has(col.toLowerCase())) continue;
+      const typeSql = this.columnTypeSql(field);
+      await this.run(`ALTER TABLE ${resource.table} ADD COLUMN ${col} ${typeSql}`);
+      console.log(`Added column: ${resource.table}.${col}`);
+    }
+
+    if (resource.softDelete && !existingSet.has("deleted_at")) {
+      const type =
+        this.dialect === "postgres"
+          ? "TIMESTAMPTZ"
+          : this.dialect === "mysql"
+            ? "VARCHAR(50) NULL"
+            : "TEXT";
+      await this.run(`ALTER TABLE ${resource.table} ADD COLUMN deleted_at ${type}`);
+      console.log(`Added column: ${resource.table}.deleted_at`);
+    }
+  }
+
+  async listColumns(table: string): Promise<string[]> {
+    const t = safeIdent(table, "");
+    if (!t) return [];
+    if (this.dialect === "sqlite") {
+      const rows = await this.query(`PRAGMA table_info(${t})`);
+      return rows.map((r) => String(r.name));
+    }
+    if (this.dialect === "postgres") {
+      const rows = await this.query(
+        `SELECT column_name as name FROM information_schema.columns WHERE table_name = ?`,
+        [t]
+      );
+      return rows.map((r) => String(r.name));
+    }
+    const rows = await this.query(`SHOW COLUMNS FROM \`${t}\``);
+    return rows.map((r) => String(r.Field ?? r.field ?? r.name));
+  }
+
+  private columnTypeSql(field: FieldDef): string {
+    if (this.dialect === "postgres") return pgSqlType(field);
+    if (this.dialect === "mysql") return mySqlType(field);
+    return sqlType(field);
+  }
+
+  private async ensurePivotTables(resource: ResourceDefinition): Promise<void> {
+    for (const [, field] of Object.entries(resource.fields)) {
+      if (field.type !== "belongsToMany" || !field.relation) continue;
+      const pivot = field.pivot ?? pivotTableFor(resource.table, field.relation);
+      const a = foreignKeyFor(resource.table);
+      const b = foreignKeyFor(field.relation);
+      if (this.dialect === "postgres") {
+        await this.run(`
+          CREATE TABLE IF NOT EXISTS ${pivot} (
+            id SERIAL PRIMARY KEY,
+            ${a} INTEGER NOT NULL,
+            ${b} INTEGER NOT NULL,
+            UNIQUE(${a}, ${b})
+          )
+        `);
+      } else if (this.dialect === "mysql") {
+        await this.run(`
+          CREATE TABLE IF NOT EXISTS ${pivot} (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            ${a} INT NOT NULL,
+            ${b} INT NOT NULL,
+            UNIQUE KEY uq_pivot (${a}, ${b})
+          )
+        `);
+      } else {
+        await this.run(`
+          CREATE TABLE IF NOT EXISTS ${pivot} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ${a} INTEGER NOT NULL,
+            ${b} INTEGER NOT NULL,
+            UNIQUE(${a}, ${b})
+          )
+        `);
+      }
+    }
+  }
+
+  async findAll(table: string, opts?: QueryOpts): Promise<DbRow[]> {
+    return Promise.resolve(this.driver.findAll(table, opts));
+  }
+
+  async paginate(
+    table: string,
+    resource: ResourceDefinition,
+    opts: QueryOpts,
+    baseUrl: string
+  ): Promise<PaginatedResult<DbRow>> {
+    const page = Math.floor((opts.offset ?? 0) / (opts.limit ?? 20)) + 1;
+    const perPage = opts.limit ?? 20;
+    const queryOpts = {
+      ...opts,
+      searchFields: opts.search ? searchFieldsFor(resource) : undefined,
+    };
+    const total = await Promise.resolve(this.driver.count(table, queryOpts));
+    const items = await Promise.resolve(this.driver.findAll(table, queryOpts));
+    return paginate(items, total, page, perPage, baseUrl);
+  }
+
+  async findById(table: string, id: number): Promise<DbRow | null> {
+    return Promise.resolve(this.driver.findById(table, id));
+  }
+
+  async insert(table: string, data: Record<string, unknown>): Promise<DbRow> {
+    return Promise.resolve(this.driver.insert(table, data));
+  }
+
+  async update(
+    table: string,
+    id: number,
+    data: Record<string, unknown>
+  ): Promise<DbRow | null> {
+    return Promise.resolve(this.driver.update(table, id, data));
+  }
+
+  async delete(table: string, id: number): Promise<boolean> {
+    return Promise.resolve(this.driver.delete(table, id));
+  }
+
+  async softDelete(table: string, id: number): Promise<boolean> {
+    const row = await this.findById(table, id);
+    if (!row) return false;
+    await this.update(table, id, { deleted_at: new Date().toISOString() });
+    return true;
+  }
+
+  async restore(table: string, id: number): Promise<boolean> {
+    const row = await this.findById(table, id);
+    if (!row) return false;
+    await this.run(`UPDATE ${table} SET deleted_at = NULL WHERE id = ?`, [id]);
+    return true;
+  }
+
+  async query(sql: string, params?: unknown[]): Promise<DbRow[]> {
+    return Promise.resolve(this.driver.query(sql, params));
+  }
+
+  async getOne(sql: string, params?: unknown[]): Promise<DbRow | null> {
+    return Promise.resolve(this.driver.getOne(sql, params));
+  }
+
+  async run(sql: string, params?: unknown[]): Promise<void> {
+    await Promise.resolve(this.driver.run(sql, params));
+  }
+
+  close(): void {
+    this.driver.close();
+  }
+}
+
+export function createDatabase(connection: string): Database {
+  return new Database(connection);
+}
+
+export function dbConnection(): string {
+  const url = process.env.DATABASE_URL;
+  if (url) return url;
+  return process.env.DB_PATH ?? "./app.db";
+}
+
+export { searchFieldsFor } from "./sqlite.js";
+export type { QueryOpts, PaginatedResult } from "./query.js";
+export type { DbDialect } from "./types.js";
+export { QueryBuilder } from "./builder.js";

package/packages/database/src/dialect.ts

@@ -0,0 +1,186 @@
+import type { DbDialect } from "../../database/src/types.js";
+
+export function migrationsTableSql(dialect: DbDialect): string {
+  if (dialect === "postgres") {
+    return `
+      CREATE TABLE IF NOT EXISTS _nexa_migrations (
+        id SERIAL PRIMARY KEY,
+        name TEXT UNIQUE NOT NULL,
+        ran_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+  }
+  if (dialect === "mysql") {
+    return `
+      CREATE TABLE IF NOT EXISTS _nexa_migrations (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(255) UNIQUE NOT NULL,
+        ran_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  return `
+    CREATE TABLE IF NOT EXISTS _nexa_migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT UNIQUE NOT NULL,
+      ran_at TEXT DEFAULT (datetime('now'))
+    )
+  `;
+}
+
+export function usersTableSql(dialect: DbDialect): string {
+  if (dialect === "postgres") {
+    return `
+      CREATE TABLE IF NOT EXISTS users (
+        id SERIAL PRIMARY KEY,
+        email TEXT UNIQUE NOT NULL,
+        password TEXT NOT NULL,
+        role TEXT DEFAULT 'user',
+        email_verified_at TEXT,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+  }
+  if (dialect === "mysql") {
+    return `
+      CREATE TABLE IF NOT EXISTS users (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        email VARCHAR(255) UNIQUE NOT NULL,
+        password TEXT NOT NULL,
+        role VARCHAR(50) DEFAULT 'user',
+        email_verified_at VARCHAR(50) NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  return `
+    CREATE TABLE IF NOT EXISTS users (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      email TEXT UNIQUE NOT NULL,
+      password TEXT NOT NULL,
+      role TEXT DEFAULT 'user',
+      email_verified_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `;
+}
+
+export function passwordResetsTableSql(dialect: DbDialect): string {
+  if (dialect === "postgres") {
+    return `
+      CREATE TABLE IF NOT EXISTS password_resets (
+        id SERIAL PRIMARY KEY,
+        email TEXT NOT NULL,
+        token TEXT NOT NULL,
+        expires_at TEXT NOT NULL,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+  }
+  if (dialect === "mysql") {
+    return `
+      CREATE TABLE IF NOT EXISTS password_resets (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        email VARCHAR(255) NOT NULL,
+        token VARCHAR(255) NOT NULL,
+        expires_at VARCHAR(50) NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  return `
+    CREATE TABLE IF NOT EXISTS password_resets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      email TEXT NOT NULL,
+      token TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `;
+}
+
+export function notificationsTableSql(dialect: DbDialect): string {
+  if (dialect === "postgres") {
+    return `
+      CREATE TABLE IF NOT EXISTS notifications (
+        id SERIAL PRIMARY KEY,
+        user_id INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        body TEXT DEFAULT '',
+        data TEXT DEFAULT '{}',
+        read_at TEXT,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+  }
+  if (dialect === "mysql") {
+    return `
+      CREATE TABLE IF NOT EXISTS notifications (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        user_id INT NOT NULL,
+        type VARCHAR(100) NOT NULL,
+        title VARCHAR(255) NOT NULL,
+        body TEXT,
+        data TEXT,
+        read_at VARCHAR(50) NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  return `
+    CREATE TABLE IF NOT EXISTS notifications (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      user_id INTEGER NOT NULL,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT DEFAULT '',
+      data TEXT DEFAULT '{}',
+      read_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `;
+}
+
+export function jobsTableSql(dialect: DbDialect): string {
+  if (dialect === "postgres") {
+    return `
+      CREATE TABLE IF NOT EXISTS _nexa_jobs (
+        id SERIAL PRIMARY KEY,
+        name TEXT NOT NULL,
+        payload TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        attempts INTEGER DEFAULT 0,
+        max_tries INTEGER DEFAULT 3,
+        available_at TIMESTAMPTZ,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `;
+  }
+  if (dialect === "mysql") {
+    return `
+      CREATE TABLE IF NOT EXISTS _nexa_jobs (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        payload TEXT NOT NULL,
+        status VARCHAR(50) DEFAULT 'pending',
+        attempts INT DEFAULT 0,
+        max_tries INT DEFAULT 3,
+        available_at VARCHAR(50) NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+  }
+  return `
+    CREATE TABLE IF NOT EXISTS _nexa_jobs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      status TEXT DEFAULT 'pending',
+      attempts INTEGER DEFAULT 0,
+      max_tries INTEGER DEFAULT 3,
+      available_at TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `;
+}

package/packages/database/src/index.ts

@@ -0,0 +1,6 @@
+export { createDatabase, Database, dbConnection, searchFieldsFor, QueryBuilder } from "./database.js";
+
+export type { DbRow } from "./types.js";
+
+export type { QueryOpts, PaginatedResult } from "./query.js";
+

package/packages/database/src/mysql.ts

@@ -0,0 +1,114 @@
+import type { ResourceDefinition } from "../../core/src/resource.js";
+import { buildMySqlColumns, type DatabaseDriver, type DbRow, type QueryOpts } from "./types.js";
+import { buildQuery } from "./query.js";
+import { searchFieldsFor } from "./sqlite.js";
+
+export class MysqlDriver implements DatabaseDriver {
+  readonly dialect = "mysql" as const;
+  private pool: any;
+
+  constructor(private url: string) {}
+
+  async connect(): Promise<void> {
+    const mysql = await import("mysql2/promise");
+    this.pool = mysql.createPool(this.url);
+  }
+
+  async createTable(resource: ResourceDefinition): Promise<void> {
+    const columns = buildMySqlColumns(resource);
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS \`${resource.table}\` (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        ${columns ? `${columns},` : ""}
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+      )
+    `);
+  }
+
+  async findAll(table: string, opts: QueryOpts = {}): Promise<DbRow[]> {
+    if (!opts.search && !opts.filters && !opts.sort && !opts.softDelete) {
+      const limit = opts.limit ?? 100;
+      const offset = opts.offset ?? 0;
+      const [rows] = await this.pool.query(
+        `SELECT * FROM \`${table}\` ORDER BY id DESC LIMIT ? OFFSET ?`,
+        [limit, offset]
+      );
+      return rows as DbRow[];
+    }
+    const { sql, params } = buildQuery(table, opts);
+    const mysqlSql = sql.replace(/FROM (\w+)/, "FROM `$1`");
+    const [rows] = await this.pool.query(mysqlSql, params);
+    return rows as DbRow[];
+  }
+
+  async count(table: string, opts: QueryOpts = {}): Promise<number> {
+    if (!opts.search && !opts.filters && !opts.softDelete) {
+      const [rows] = await this.pool.query(`SELECT COUNT(*) as total FROM \`${table}\``);
+      return Number((rows as { total: number }[])[0]?.total ?? 0);
+    }
+    const { countSql, params } = buildQuery(table, { ...opts, limit: 1, offset: 0 });
+    const mysqlSql = countSql.replace(/FROM (\w+)/, "FROM `$1`");
+    const [rows] = await this.pool.query(mysqlSql, params.slice(0, -2));
+    return Number((rows as { total: number }[])[0]?.total ?? 0);
+  }
+
+  async findById(table: string, id: number): Promise<DbRow | null> {
+    const [rows] = await this.pool.query(`SELECT * FROM \`${table}\` WHERE id = ?`, [id]);
+    const list = rows as DbRow[];
+    return list[0] ?? null;
+  }
+
+  async insert(table: string, data: Record<string, unknown>): Promise<DbRow> {
+    const keys = Object.keys(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const cols = keys.map((k) => `\`${k}\``).join(", ");
+    const [result] = await this.pool.query(
+      `INSERT INTO \`${table}\` (${cols}) VALUES (${placeholders})`,
+      keys.map((k) => data[k])
+    );
+    const insertId = (result as { insertId: number }).insertId;
+    return (await this.findById(table, insertId))!;
+  }
+
+  async update(
+    table: string,
+    id: number,
+    data: Record<string, unknown>
+  ): Promise<DbRow | null> {
+    const keys = Object.keys(data);
+    if (keys.length === 0) return this.findById(table, id);
+    const setClause = keys.map((k) => `\`${k}\` = ?`).join(", ");
+    await this.pool.query(`UPDATE \`${table}\` SET ${setClause} WHERE id = ?`, [
+      ...keys.map((k) => data[k]),
+      id,
+    ]);
+    return this.findById(table, id);
+  }
+
+  async delete(table: string, id: number): Promise<boolean> {
+    const [result] = await this.pool.query(`DELETE FROM \`${table}\` WHERE id = ?`, [id]);
+    return (result as { affectedRows: number }).affectedRows > 0;
+  }
+
+  async query(sql: string, params: unknown[] = []): Promise<DbRow[]> {
+    const [rows] = await this.pool.query(sql, params);
+    return rows as DbRow[];
+  }
+
+  async getOne(sql: string, params: unknown[] = []): Promise<DbRow | null> {
+    const [rows] = await this.pool.query(sql, params);
+    const list = rows as DbRow[];
+    return list[0] ?? null;
+  }
+
+  async run(sql: string, params: unknown[] = []): Promise<void> {
+    await this.pool.query(sql, params);
+  }
+
+  close(): void {
+    this.pool?.end?.();
+  }
+}
+
+export { searchFieldsFor };

package/packages/database/src/postgres.ts

@@ -0,0 +1,117 @@
+import type { ResourceDefinition } from "../../core/src/resource.js";
+import { buildPgColumns, type DatabaseDriver, type DbRow, type QueryOpts } from "./types.js";
+import { buildQuery } from "./query.js";
+import { searchFieldsFor } from "./sqlite.js";
+
+function pgPlaceholders(sql: string): string {
+  let i = 0;
+  return sql.replace(/\?/g, () => `$${++i}`);
+}
+
+export class PostgresDriver implements DatabaseDriver {
+  readonly dialect = "postgres" as const;
+  private sql: any;
+
+  constructor(private url: string) {}
+
+  async connect(): Promise<void> {
+    const postgres = (await import("postgres")).default;
+    this.sql = postgres(this.url);
+  }
+
+  async createTable(resource: ResourceDefinition): Promise<void> {
+    const columns = buildPgColumns(resource);
+    await this.sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${resource.table} (
+        id SERIAL PRIMARY KEY,
+        ${columns ? `${columns},` : ""}
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `);
+  }
+
+  async findAll(table: string, opts: QueryOpts = {}): Promise<DbRow[]> {
+    if (!opts.search && !opts.filters && !opts.sort && !opts.softDelete) {
+      const limit = opts.limit ?? 100;
+      const offset = opts.offset ?? 0;
+      return (await this.sql.unsafe(
+        `SELECT * FROM ${table} ORDER BY id DESC LIMIT ${limit} OFFSET ${offset}`
+      )) as DbRow[];
+    }
+    const { sql, params } = buildQuery(table, opts);
+    return (await this.sql.unsafe(pgPlaceholders(sql), params)) as DbRow[];
+  }
+
+  async count(table: string, opts: QueryOpts = {}): Promise<number> {
+    if (!opts.search && !opts.filters && !opts.softDelete) {
+      const rows = (await this.sql.unsafe(
+        `SELECT COUNT(*)::int as total FROM ${table}`
+      )) as { total: number }[];
+      return Number(rows[0]?.total ?? 0);
+    }
+    const { countSql, params } = buildQuery(table, { ...opts, limit: 1, offset: 0 });
+    const rows = (await this.sql.unsafe(
+      pgPlaceholders(countSql),
+      params.slice(0, -2)
+    )) as { total: number }[];
+    return Number(rows[0]?.total ?? 0);
+  }
+
+  async findById(table: string, id: number): Promise<DbRow | null> {
+    const rows = (await this.sql.unsafe(`SELECT * FROM ${table} WHERE id = $1`, [id])) as DbRow[];
+    return rows[0] ?? null;
+  }
+
+  async insert(table: string, data: Record<string, unknown>): Promise<DbRow> {
+    const keys = Object.keys(data);
+    const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
+    const rows = (await this.sql.unsafe(
+      `INSERT INTO ${table} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`,
+      keys.map((k) => data[k])
+    )) as DbRow[];
+    return rows[0];
+  }
+
+  async update(
+    table: string,
+    id: number,
+    data: Record<string, unknown>
+  ): Promise<DbRow | null> {
+    const keys = Object.keys(data);
+    if (keys.length === 0) return this.findById(table, id);
+    const setClause = keys.map((k, i) => `${k} = $${i + 1}`).join(", ");
+    const params = [...keys.map((k) => data[k]), id];
+    await this.sql.unsafe(
+      `UPDATE ${table} SET ${setClause}, updated_at = NOW() WHERE id = $${keys.length + 1}`,
+      params
+    );
+    return this.findById(table, id);
+  }
+
+  async delete(table: string, id: number): Promise<boolean> {
+    const rows = (await this.sql.unsafe(`DELETE FROM ${table} WHERE id = $1 RETURNING id`, [
+      id,
+    ])) as DbRow[];
+    return rows.length > 0;
+  }
+
+  async query(sql: string, params: unknown[] = []): Promise<DbRow[]> {
+    return (await this.sql.unsafe(pgPlaceholders(sql), params)) as DbRow[];
+  }
+
+  async getOne(sql: string, params: unknown[] = []): Promise<DbRow | null> {
+    const rows = (await this.sql.unsafe(pgPlaceholders(sql), params)) as DbRow[];
+    return rows[0] ?? null;
+  }
+
+  async run(sql: string, params: unknown[] = []): Promise<void> {
+    await this.sql.unsafe(pgPlaceholders(sql), params);
+  }
+
+  close(): void {
+    this.sql?.end?.();
+  }
+}
+
+export { searchFieldsFor };