feat(columns): allow include/exclude schema(s)

Author: osaxma

src/lib/PostgresMetaColumns.ts

@@ -16,11 +16,15 @@ export default class PostgresMetaColumns {
   async list({
     tableId,
     includeSystemSchemas = false,
+    includedSchemas,
+    excludedSchemas,
     limit,
     offset,
   }: {
     tableId?: number
     includeSystemSchemas?: boolean
+    includedSchemas?: string[]
+    excludedSchemas?: string[]
     limit?: number
     offset?: number
   } = {}): Promise<PostgresMetaResult<PostgresColumn[]>> {
@@ -33,9 +37,17 @@ FROM
   columns
 WHERE
   true`
-    if (!includeSystemSchemas) {
-      sql += ` AND schema NOT IN (${DEFAULT_SYSTEM_SCHEMAS.map(literal).join(',')})`
+
+    if (includedSchemas?.length) {
+      sql = `${sql} AND (schema IN (${includedSchemas.map(literal).join(',')}))`
+    } else if (!includeSystemSchemas) {
+      sql = `${sql} AND NOT (schema IN (${DEFAULT_SYSTEM_SCHEMAS.map(literal).join(',')}))`
+    }
+
+    if (excludedSchemas?.length) {
+      sql = `${sql} AND NOT (schema IN (${excludedSchemas.map(literal).join(',')}))`
     }
+
     if (tableId !== undefined) {
       sql += ` AND table_id = ${literal(tableId)}`
     }

src/server/routes/columns.ts

@@ -8,18 +8,25 @@ export default async (fastify: FastifyInstance) => {
     Headers: { pg: string }
     Querystring: {
       include_system_schemas?: string
+      // Note: this only supports comma separated values (e.g., ".../columns?included_schemas=public,core")
+      included_schemas?: string
+      excluded_schemas?: string
       limit?: number
       offset?: number
     }
   }>('/', 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 limit = request.query.limit
     const offset = request.query.offset
 
     const pgMeta = new PostgresMeta({ ...DEFAULT_POOL_CONFIG, connectionString })
     const { data, error } = await pgMeta.columns.list({
       includeSystemSchemas,
+      includedSchemas,
+      excludedSchemas,
       limit,
       offset,
     })

test/lib/columns.ts

@@ -99,6 +99,41 @@ test('list from a single table', async () => {
   await pgMeta.tables.remove(testTable!.id)
 })
 
+test('list columns with included schemas', async () => {
+  let res = await pgMeta.columns.list({
+    includedSchemas: ['public']
+  })
+
+  expect(res.data?.length).toBeGreaterThan(0)
+
+  res.data?.forEach((column) => {
+    expect(column.schema).toBe('public')
+  })
+}) 
+
+test('list columns with excluded schemas', async () => {
+  let res = await pgMeta.columns.list({
+    excludedSchemas: ['public'],
+  })
+  
+  res.data?.forEach((column) => {
+    expect(column.schema).not.toBe('public')
+  })
+}) 
+
+test('list columns with excluded schemas and include System Schemas', async () => {
+  let res = await pgMeta.columns.list({
+    excludedSchemas: ['public'],
+    includeSystemSchemas: true,
+  })
+
+  expect(res.data?.length).toBeGreaterThan(0)
+
+  res.data?.forEach((column) => {
+    expect(column.schema).not.toBe('public')
+  })
+}) 
+
 test('retrieve, create, update, delete', async () => {
   const { data: testTable }: any = await pgMeta.tables.create({ name: 't' })