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

Author: osaxma

src/lib/PostgresMetaTables.ts

@@ -13,17 +13,33 @@ export default class PostgresMetaTables {
 
   async list({
     includeSystemSchemas = false,
+    includedSchemas,
+    excludedSchemas,
     limit,
     offset,
   }: {
     includeSystemSchemas?: boolean
+    includedSchemas?: string[]
+    excludedSchemas?: string[]
     limit?: number
     offset?: number
   } = {}): Promise<PostgresMetaResult<PostgresTable[]>> {
     let sql = enrichedTablesSql
-    if (!includeSystemSchemas) {
+
+    if (includedSchemas?.length) {
+      sql = `${sql} WHERE (schema IN (${includedSchemas.map(literal).join(',')}))`
+    } else if (!includeSystemSchemas) {
       sql = `${sql} WHERE NOT (schema IN (${DEFAULT_SYSTEM_SCHEMAS.map(literal).join(',')}))`
     }
+
+    if (excludedSchemas?.length) {
+      if (includedSchemas?.length || !includeSystemSchemas) {
+        sql = `${sql} AND NOT (schema IN (${excludedSchemas.map(literal).join(',')}))`
+      } else {
+        sql = `${sql} WHERE NOT (schema IN (${excludedSchemas.map(literal).join(',')}))`
+      }
+    }
+
     if (limit) {
       sql = `${sql} LIMIT ${limit}`
     }

src/server/routes/tables.ts

@@ -8,17 +8,22 @@ export default async (fastify: FastifyInstance) => {
     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
       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.tables.list({ includeSystemSchemas, limit, offset })
+    const { data, error } = await pgMeta.tables.list({ includeSystemSchemas, includedSchemas, excludedSchemas, limit, offset })
     await pgMeta.end()
     if (error) {
       request.log.error({ error, request: extractRequestForLogging(request) })

test/lib/tables.ts

@@ -129,6 +129,41 @@ test('list', async () => {
   )
 })
 
+test('list tables with included schemas', async () => {
+  let res = await pgMeta.tables.list({
+    includedSchemas: ['public']
+  })
+
+  expect(res.data?.length).toBeGreaterThan(0)
+
+  res.data?.forEach((table) => {
+    expect(table.schema).toBe('public')
+  })
+}) 
+
+test('list tables with excluded schemas', async () => {
+  let res = await pgMeta.tables.list({
+    excludedSchemas: ['public'],
+  })
+  
+  res.data?.forEach((table) => {
+    expect(table.schema).not.toBe('public')
+  })
+}) 
+
+test('list tables with excluded schemas and include System Schemas', async () => {
+  let res = await pgMeta.tables.list({
+    excludedSchemas: ['public'],
+    includeSystemSchemas: true,
+  })
+
+  expect(res.data?.length).toBeGreaterThan(0)
+
+  res.data?.forEach((table) => {
+    expect(table.schema).not.toBe('public')
+  })
+}) 
+
 test('retrieve, create, update, delete', async () => {
   let res = await pgMeta.tables.create({ name: 'test', comment: 'foo' })
   expect(cleanNondet(res)).toMatchInlineSnapshot(