feat: support table count via HEAD

src/lib/PostgresMetaTables.ts

@@ -2,7 +2,7 @@ import { ident, literal } from 'pg-format'
 import { DEFAULT_SYSTEM_SCHEMAS } from './constants.js'
 import { coalesceRowsToArray, filterByList } from './helpers.js'
 import { columnsSql, primaryKeysSql, relationshipsSql, tablesSql } from './sql/index.js'
-import { PostgresMetaResult, PostgresTable } from './types.js'
+import { FilterParams, PaginationParams, PostgresMetaResult, PostgresTable } from './types.js'
 
 export default class PostgresMetaTables {
   query: (sql: string) => Promise<PostgresMetaResult<any>>
@@ -11,19 +11,36 @@ export default class PostgresMetaTables {
     this.query = query
   }
 
+  async count({
+    includeSystemSchemas = false,
+    includedSchemas,
+    excludedSchemas,
+  }: FilterParams = {}): Promise<PostgresMetaResult<{ count: number }>> {
+    let sql = `WITH tables AS (${tablesSql}) SELECT count(1) FROM tables`
+    const filter = filterByList(
+      includedSchemas,
+      excludedSchemas,
+      !includeSystemSchemas ? DEFAULT_SYSTEM_SCHEMAS : undefined
+    )
+    if (filter) {
+      sql += ` WHERE schema ${filter}`
+    }
+
+    const { data, error } = await this.query(sql)
+    if (error) {
+      return { data, error }
+    } else {
+      return { data: data[0], error }
+    }
+  }
+
   async list({
     includeSystemSchemas = false,
     includedSchemas,
     excludedSchemas,
     limit,
     offset,
-  }: {
-    includeSystemSchemas?: boolean
-    includedSchemas?: string[]
-    excludedSchemas?: string[]
-    limit?: number
-    offset?: number
-  } = {}): Promise<PostgresMetaResult<PostgresTable[]>> {
+  }: FilterParams & PaginationParams = {}): Promise<PostgresMetaResult<PostgresTable[]>> {
     let sql = enrichedTablesSql
     const filter = filterByList(
       includedSchemas,

src/lib/types.ts

@@ -3,6 +3,19 @@ import { Options as PrettierOptions } from 'prettier'
 
 export interface FormatterOptions extends PrettierOptions {}
 
+// Request types
+export interface FilterParams {
+  includeSystemSchemas?: boolean
+  includedSchemas?: string[]
+  excludedSchemas?: string[]
+}
+
+export interface PaginationParams {
+  limit?: number
+  offset?: number
+}
+
+// Response types
 export interface PostgresMetaOk<T> {
   data: T
   error: null

src/server/app.ts

@@ -33,6 +33,7 @@ const app = fastify({
   logger,
   disableRequestLogging: true,
   requestIdHeader: PG_META_REQ_HEADER,
+  ignoreTrailingSlash: true,
 })
 
 app.setErrorHandler((error, request, reply) => {

src/server/routes/tables.ts

@@ -4,6 +4,36 @@ import { DEFAULT_POOL_CONFIG } from '../constants.js'
 import { extractRequestForLogging, translateErrorToResponseCode } from '../utils.js'
 
 export default async (fastify: FastifyInstance) => {
+  fastify.head<{
+    Headers: { pg: string }
+    Querystring: {
+      include_system_schemas?: string
+      // Note: this only supports comma separated values (e.g., ".../tables?included_schemas=public,core")
+      included_schemas?: string
+      excluded_schemas?: string
+    }
+  }>('/', async (request, reply) => {
+    const connectionString = request.headers.pg
+    const includeSystemSchemas = request.query.include_system_schemas === 'true'
+    const includedSchemas = request.query.included_schemas?.split(',')
+    const excludedSchemas = request.query.excluded_schemas?.split(',')
+
+    const pgMeta = new PostgresMeta({ ...DEFAULT_POOL_CONFIG, connectionString })
+    const { data, error } = await pgMeta.tables.count({
+      includeSystemSchemas,
+      includedSchemas,
+      excludedSchemas,
+    })
+    await pgMeta.end()
+    if (error) {
+      request.log.error({ error, request: extractRequestForLogging(request) })
+      reply.code(translateErrorToResponseCode(error, 500))
+      return { error: error.message }
+    }
+
+    return reply.header('content-range', `*/${data.count}`).send()
+  })
+
   fastify.get<{
     Headers: { pg: string }
     Querystring: {

test/lib/tables.ts

@@ -17,6 +17,19 @@ const cleanNondet = (x: any) => {
   }
 }
 
+test('count', async () => {
+  const res = await pgMeta.tables.count()
+
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "data": Object {
+        "count": 5,
+      },
+      "error": null,
+    }
+  `)
+})
+
 test('list', async () => {
   const res = await pgMeta.tables.list()