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

Author: osaxma

src/lib/PostgresMetaTypes.ts

@@ -12,17 +12,29 @@ export default class PostgresMetaTypes {
 
   async list({
     includeSystemSchemas = false,
+    includedSchemas,
+    excludedSchemas,
     limit,
     offset,
   }: {
     includeSystemSchemas?: boolean
+    includedSchemas?: string[]
+    excludedSchemas?: string[]
     limit?: number
     offset?: number
   } = {}): Promise<PostgresMetaResult<PostgresType[]>> {
     let sql = typesSql
-    if (!includeSystemSchemas) {
+
+    if (includedSchemas?.length) {
+      sql = `${sql} AND (n.nspname IN (${includedSchemas.map(literal).join(',')}))`
+    } else if (!includeSystemSchemas) {
       sql = `${sql} AND NOT (n.nspname IN (${DEFAULT_SYSTEM_SCHEMAS.map(literal).join(',')}))`
     }
+
+    if (excludedSchemas?.length) {
+      sql = `${sql} AND NOT (n.nspname IN (${excludedSchemas.map(literal).join(',')}))`
+    }
+
     if (limit) {
       sql = `${sql} LIMIT ${limit}`
     }

src/server/routes/types.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., ".../types?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.types.list({ includeSystemSchemas, limit, offset })
+    const { data, error } = await pgMeta.types.list({ includeSystemSchemas, includedSchemas, excludedSchemas, limit, offset })
     await pgMeta.end()
     if (error) {
       request.log.error({ error, request: extractRequestForLogging(request) })

test/lib/types.ts

@@ -19,3 +19,39 @@ test('list', async () => {
   `
   )
 })
+
+
+test('list types with included schemas', async () => {
+  let res = await pgMeta.types.list({
+    includedSchemas: ['public']
+  })
+
+  expect(res.data?.length).toBeGreaterThan(0)
+
+  res.data?.forEach((type) => {
+    expect(type.schema).toBe('public')
+  })
+}) 
+
+test('list types with excluded schemas', async () => {
+  let res = await pgMeta.types.list({
+    excludedSchemas: ['public'],
+  })
+  
+  res.data?.forEach((type) => {
+    expect(type.schema).not.toBe('public')
+  })
+}) 
+
+test('list types with excluded schemas and include System Schemas', async () => {
+  let res = await pgMeta.types.list({
+    excludedSchemas: ['public'],
+    includeSystemSchemas: true,
+  })
+
+  expect(res.data?.length).toBeGreaterThan(0)
+
+  res.data?.forEach((type) => {
+    expect(type.schema).not.toBe('public')
+  })
+})