Use @fastify/fastify-postgres. CheckerNetwork/roadmap#220

db/package.json

@@ -14,7 +14,9 @@
   "dependencies": {
     "@filecoin-station/spark-evaluate": "^1.2.0",
     "pg": "^8.13.3",
-    "postgrator": "^8.0.0"
+    "postgrator": "^8.0.0",
+    "@fastify/postgres": "^5.2.0",
+    "@fastify/url-data": "^6.0.3"
   },
   "standard": {
     "env": [

stats/bin/migrate.js

@@ -1,9 +1,38 @@
+import Fastify from 'fastify'
+import fastifyPostgres from '@fastify/postgres'
 import {
-  getPgPools,
   migrateEvaluateDB,
   migrateStatsDB
 } from '@filecoin-station/spark-stats-db'
 
-const pgPools = await getPgPools()
-await migrateStatsDB(pgPools.stats)
-await migrateEvaluateDB(pgPools.evaluate)
+const {
+  DATABASE_URL,
+  EVALUATE_DB_URL
+} = process.env
+
+const app = Fastify({ logger: false })
+
+await app.register(fastifyPostgres, {
+  connectionString: DATABASE_URL,
+  name: 'stats'
+})
+
+await app.register(fastifyPostgres, {
+  connectionString: EVALUATE_DB_URL,
+  name: 'evaluate'
+})
+
+try {
+  console.log('Running migrations for stats database...')
+  await migrateStatsDB(app.pg.stats)
+
+  console.log('Running migrations for evaluate database...')
+  await migrateEvaluateDB(app.pg.evaluate)
+
+  console.log('All migrations completed successfully')
+} catch (error) {
+  console.error('Migration failed:', error)
+  process.exit(1)
+} finally {
+  await app.close()
+}

stats/bin/spark-stats.js

@@ -1,16 +1,50 @@
 import '../lib/instrument.js'
+import Fastify from 'fastify'
+import fastifyPostgres from '@fastify/postgres'
 import { createApp } from '../lib/app.js'
-import { getPgPools } from '@filecoin-station/spark-stats-db'
 
 const {
   PORT = '8080',
   HOST = '127.0.0.1',
   SPARK_API_BASE_URL = 'https://api.filspark.com/',
-  REQUEST_LOGGING = 'true'
+  REQUEST_LOGGING = 'true',
+  DATABASE_URL,
+
 } = process.env
 
 const pgPools = await getPgPools()
 
+const dbFastify = Fastify({ logger: false })
+
+await dbFastify.register(fastifyPostgres, {
+  connectionString: DATABASE_URL,
+  name: 'stats',
+  pool: {
+    min: 0,
+    max: 100,
+    idleTimeoutMillis: 1000,
+    maxLifetimeSeconds: 60
+  }
+})
+
+const pgPools = {
+  stats: dbFastify.pg.stats,
+  evaluate: dbFastify.pg.evaluate,
+  async end() {
+    await dbFastify.close()
+  }
+}
+
+
+export const withDb = async (poolName, queryFn) => {
+  const client = await dbFastify.pg[poolName].connect()
+  try {
+    return await queryFn(client)
+  } finally {
+    client.release()
+  }
+}
+
 const app = await createApp({
   SPARK_API_BASE_URL,
   pgPools,

stats/lib/db.js

@@ -0,0 +1,113 @@
+// stats/lib/db.js
+import Fastify from 'fastify'
+import fastifyPostgres from '@fastify/postgres'
+
+let fastifyApp = null
+let isInitialized = false
+
+/**
+ * Initialize database connections
+ * @param {Object} options 
+ * @param {string} options.statsConnectionString - Stats DB connection string
+ * @param {string} options.evaluateConnectionString - Evaluate DB connection string
+ * @returns {Promise<void>}
+ */
+export async function initializeDb({ statsConnectionString, evaluateConnectionString }) {
+  if (isInitialized) return
+
+  // Create a minimal Fastify instance for database connections
+  fastifyApp = Fastify({ logger: false })
+
+  // Register the Postgres plugin for stats DB
+  await fastifyApp.register(fastifyPostgres, {
+    connectionString: statsConnectionString,
+    name: 'stats',
+    pool: {
+      min: 0,
+      max: 100,
+      idleTimeoutMillis: 1000,
+      maxLifetimeSeconds: 60
+    }
+  })
+
+  // Register the Postgres plugin for evaluate DB
+  await fastifyApp.register(fastifyPostgres, {
+    connectionString: evaluateConnectionString,
+    name: 'evaluate',
+    pool: {
+      min: 0,
+      max: 100,
+      idleTimeoutMillis: 1000,
+      maxLifetimeSeconds: 60
+    }
+  })
+
+  isInitialized = true
+  console.log('Database connections initialized')
+}
+
+/**
+ * Execute a query on the stats database
+ * @param {Function} queryFn - Function that takes a client and executes a query
+ * @returns {Promise<*>} The result of the query function
+ */
+export async function withStatsDb(queryFn) {
+  if (!isInitialized) {
+    throw new Error('Database connections not initialized')
+  }
+
+  const client = await fastifyApp.pg.stats.connect()
+  try {
+    return await queryFn(client)
+  } finally {
+    client.release()
+  }
+}
+
+/**
+ * Execute a query on the evaluate database
+ * @param {Function} queryFn - Function that takes a client and executes a query
+ * @returns {Promise<*>} The result of the query function
+ */
+export async function withEvaluateDb(queryFn) {
+  if (!isInitialized) {
+    throw new Error('Database connections not initialized')
+  }
+
+  const client = await fastifyApp.pg.evaluate.connect()
+  try {
+    return await queryFn(client)
+  } finally {
+    client.release()
+  }
+}
+
+/**
+ * Get PgPools object compatible with the existing API
+ * @returns {Object} PgPools object
+ */
+export function getPgPools() {
+  if (!isInitialized) {
+    throw new Error('Database connections not initialized')
+  }
+
+  return {
+    stats: fastifyApp.pg.stats,
+    evaluate: fastifyApp.pg.evaluate,
+    async end() {
+      await closeDb()
+    }
+  }
+}
+
+/**
+ * Close all database connections
+ * @returns {Promise<void>}
+ */
+export async function closeDb() {
+  if (isInitialized && fastifyApp) {
+    await fastifyApp.close()
+    isInitialized = false
+    console.log('Database connections closed')
+  }
+}