feat(columns): allow getting columns from a single table

Author: soedirgo

Diff for: src/lib/PostgresMetaColumns.ts

@@ -14,23 +14,36 @@ export default class PostgresMetaColumns {
   }
 
   async list({
+    tableId,
     includeSystemSchemas = false,
     limit,
     offset,
   }: {
+    tableId?: number
     includeSystemSchemas?: boolean
     limit?: number
     offset?: number
   } = {}): Promise<PostgresMetaResult<PostgresColumn[]>> {
-    let sql = columnsSql
+    let sql = `
+WITH
+  columns AS (${columnsSql})
+SELECT
+  *
+FROM
+  columns
+WHERE
+  true`
     if (!includeSystemSchemas) {
-      sql = `${sql} AND NOT (nc.nspname IN (${DEFAULT_SYSTEM_SCHEMAS.map(literal).join(',')}))`
+      sql += ` AND schema NOT IN (${DEFAULT_SYSTEM_SCHEMAS.map(literal).join(',')})`
+    }
+    if (tableId !== undefined) {
+      sql += ` AND table_id = ${literal(tableId)}`
     }
     if (limit) {
-      sql = `${sql} LIMIT ${limit}`
+      sql += ` LIMIT ${limit}`
     }
     if (offset) {
-      sql = `${sql} OFFSET ${offset}`
+      sql += ` OFFSET ${offset}`
     }
     return await this.query(sql)
   }

Diff for: src/server/routes/columns.ts

@@ -33,6 +33,39 @@ export default async (fastify: FastifyInstance) => {
     return data
   })
 
+  fastify.get<{
+    Headers: { pg: string }
+    Params: { tableId: number }
+    Querystring: {
+      include_system_schemas?: string
+      limit?: number
+      offset?: number
+    }
+  }>('/:tableId(^\\d+$)', async (request, reply) => {
+    const {
+      headers: { pg: connectionString },
+      query: { limit, offset },
+      params: { tableId },
+    } = request
+    const includeSystemSchemas = request.query.include_system_schemas === 'true'
+
+    const pgMeta: PostgresMeta = new PostgresMeta({ ...DEFAULT_POOL_CONFIG, connectionString })
+    const { data, error } = await pgMeta.columns.list({
+      tableId,
+      includeSystemSchemas,
+      limit,
+      offset,
+    })
+    await pgMeta.end()
+    if (error) {
+      request.log.error({ error, request: extractRequestForLogging(request) })
+      reply.code(500)
+      return { error: error.message }
+    }
+
+    return data
+  })
+
   fastify.get<{
     Headers: { pg: string }
     Params: {

Diff for: test/lib/columns.ts

@@ -31,6 +31,74 @@ test('list', async () => {
   )
 })
 
+test('list from a single table', async () => {
+  const { data: testTable }: any = await pgMeta.tables.create({ name: 't' })
+  await pgMeta.query('alter table t add c1 text, add c2 text')
+
+  const res = await pgMeta.columns.list({ tableId: testTable!.id })
+  expect(res).toMatchInlineSnapshot(
+    {
+      data: [
+        {
+          id: expect.stringMatching(/^\d+\.\d+$/),
+          table_id: expect.any(Number),
+        },
+        {
+          id: expect.stringMatching(/^\d+\.\d+$/),
+          table_id: expect.any(Number),
+        },
+      ],
+    },
+    `
+    Object {
+      "data": Array [
+        Object {
+          "comment": null,
+          "data_type": "text",
+          "default_value": null,
+          "enums": Array [],
+          "format": "text",
+          "id": StringMatching /\\^\\\\d\\+\\\\\\.\\\\d\\+\\$/,
+          "identity_generation": null,
+          "is_generated": false,
+          "is_identity": false,
+          "is_nullable": true,
+          "is_unique": false,
+          "is_updatable": true,
+          "name": "c1",
+          "ordinal_position": 1,
+          "schema": "public",
+          "table": "t",
+          "table_id": Any<Number>,
+        },
+        Object {
+          "comment": null,
+          "data_type": "text",
+          "default_value": null,
+          "enums": Array [],
+          "format": "text",
+          "id": StringMatching /\\^\\\\d\\+\\\\\\.\\\\d\\+\\$/,
+          "identity_generation": null,
+          "is_generated": false,
+          "is_identity": false,
+          "is_nullable": true,
+          "is_unique": false,
+          "is_updatable": true,
+          "name": "c2",
+          "ordinal_position": 2,
+          "schema": "public",
+          "table": "t",
+          "table_id": Any<Number>,
+        },
+      ],
+      "error": null,
+    }
+  `
+  )
+
+  await pgMeta.tables.remove(testTable!.id)
+})
+
 test('retrieve, create, update, delete', async () => {
   const { data: testTable }: any = await pgMeta.tables.create({ name: 't' })