Merge pull request #415 from supabase/feat/foreign-tables

feat: foreign tables

Author: soedirgo

src/lib/PostgresMeta.ts

@@ -3,6 +3,7 @@ import * as Parser from './Parser'
 import PostgresMetaColumns from './PostgresMetaColumns'
 import PostgresMetaConfig from './PostgresMetaConfig'
 import PostgresMetaExtensions from './PostgresMetaExtensions'
+import PostgresMetaForeignTables from './PostgresMetaForeignTables'
 import PostgresMetaFunctions from './PostgresMetaFunctions'
 import PostgresMetaPolicies from './PostgresMetaPolicies'
 import PostgresMetaPublications from './PostgresMetaPublications'
@@ -15,12 +16,14 @@ import PostgresMetaVersion from './PostgresMetaVersion'
 import PostgresMetaViews from './PostgresMetaViews'
 import { init } from './db'
 import { PostgresMetaResult } from './types'
+
 export default class PostgresMeta {
   query: (sql: string) => Promise<PostgresMetaResult<any>>
   end: () => Promise<void>
   columns: PostgresMetaColumns
   config: PostgresMetaConfig
   extensions: PostgresMetaExtensions
+  foreignTables: PostgresMetaForeignTables
   functions: PostgresMetaFunctions
   policies: PostgresMetaPolicies
   publications: PostgresMetaPublications
@@ -43,6 +46,7 @@ export default class PostgresMeta {
     this.columns = new PostgresMetaColumns(this.query)
     this.config = new PostgresMetaConfig(this.query)
     this.extensions = new PostgresMetaExtensions(this.query)
+    this.foreignTables = new PostgresMetaForeignTables(this.query)
     this.functions = new PostgresMetaFunctions(this.query)
     this.policies = new PostgresMetaPolicies(this.query)
     this.publications = new PostgresMetaPublications(this.query)

src/lib/PostgresMetaForeignTables.ts

@@ -0,0 +1,36 @@
+import { coalesceRowsToArray } from './helpers'
+import { columnsSql, foreignTablesSql } from './sql'
+import { PostgresMetaResult, PostgresForeignTable } from './types'
+
+export default class PostgresMetaForeignTables {
+  query: (sql: string) => Promise<PostgresMetaResult<any>>
+
+  constructor(query: (sql: string) => Promise<PostgresMetaResult<any>>) {
+    this.query = query
+  }
+
+  async list({
+    limit,
+    offset,
+  }: {
+    limit?: number
+    offset?: number
+  } = {}): Promise<PostgresMetaResult<PostgresForeignTable[]>> {
+    let sql = enrichedForeignTablesSql
+    if (limit) {
+      sql = `${sql} LIMIT ${limit}`
+    }
+    if (offset) {
+      sql = `${sql} OFFSET ${offset}`
+    }
+    return await this.query(sql)
+  }
+}
+
+const enrichedForeignTablesSql = `
+WITH foreign_tables AS (${foreignTablesSql}),
+  columns AS (${columnsSql})
+SELECT
+  *,
+  ${coalesceRowsToArray('columns', 'columns.table_id = foreign_tables.id')}
+FROM foreign_tables`

src/lib/sql/foreign_tables.sql

@@ -0,0 +1,10 @@
+SELECT
+  c.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS name,
+  obj_description(c.oid) AS comment
+FROM
+  pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE
+  c.relkind = 'f'

src/lib/sql/index.ts

@@ -4,6 +4,7 @@ import { resolve } from 'path'
 export const columnsSql = readFileSync(resolve(__dirname, 'columns.sql'), 'utf-8')
 export const configSql = readFileSync(resolve(__dirname, 'config.sql'), 'utf-8')
 export const extensionsSql = readFileSync(resolve(__dirname, 'extensions.sql'), 'utf-8')
+export const foreignTablesSql = readFileSync(resolve(__dirname, 'foreign_tables.sql'), 'utf-8')
 export const functionsSql = readFileSync(resolve(__dirname, 'functions.sql'), 'utf-8')
 export const policiesSql = readFileSync(resolve(__dirname, 'policies.sql'), 'utf-8')
 export const primaryKeysSql = readFileSync(resolve(__dirname, 'primary_keys.sql'), 'utf-8')

src/lib/types.ts

@@ -75,6 +75,15 @@ export const postgresExtensionSchema = Type.Object({
 })
 export type PostgresExtension = Static<typeof postgresExtensionSchema>
 
+export const postgresForeignTableSchema = Type.Object({
+  id: Type.Integer(),
+  schema: Type.String(),
+  name: Type.String(),
+  comment: Type.Union([Type.String(), Type.Null()]),
+  columns: Type.Array(postgresColumnSchema),
+})
+export type PostgresForeignTable = Static<typeof postgresForeignTableSchema>
+
 const postgresFunctionSchema = Type.Object({
   id: Type.Integer(),
   schema: Type.String(),

src/server/routes/foreign-tables.ts

@@ -0,0 +1,29 @@
+import { FastifyInstance } from 'fastify'
+import { PostgresMeta } from '../../lib'
+import { DEFAULT_POOL_CONFIG } from '../constants'
+import { extractRequestForLogging } from '../utils'
+
+export default async (fastify: FastifyInstance) => {
+  fastify.get<{
+    Headers: { pg: string }
+    Querystring: {
+      limit?: number
+      offset?: number
+    }
+  }>('/', async (request, reply) => {
+    const connectionString = request.headers.pg
+    const limit = request.query.limit
+    const offset = request.query.offset
+
+    const pgMeta = new PostgresMeta({ ...DEFAULT_POOL_CONFIG, connectionString })
+    const { data, error } = await pgMeta.foreignTables.list({ limit, offset })
+    await pgMeta.end()
+    if (error) {
+      request.log.error({ error, request: extractRequestForLogging(request) })
+      reply.code(500)
+      return { error: error.message }
+    }
+
+    return data
+  })
+}

src/server/routes/index.ts

@@ -28,6 +28,7 @@ export default async (fastify: FastifyInstance) => {
   fastify.register(require('./columns'), { prefix: '/columns' })
   fastify.register(require('./config'), { prefix: '/config' })
   fastify.register(require('./extensions'), { prefix: '/extensions' })
+  fastify.register(require('./foreign-tables'), { prefix: '/foreign-tables' })
   fastify.register(require('./functions'), { prefix: '/functions' })
   fastify.register(require('./policies'), { prefix: '/policies' })
   fastify.register(require('./publications'), { prefix: '/publications' })

test/db/00-init.sql

@@ -56,3 +56,12 @@ create function public.blurb(public.todos) returns text as
 $$
 select substring($1.details, 1, 3);
 $$ language sql stable;
+
+create extension postgres_fdw;
+create server foreign_server foreign data wrapper postgres_fdw options (host 'localhost', port '5432', dbname 'postgres');
+create user mapping for postgres server foreign_server options (user 'postgres', password 'postgres');
+create foreign table foreign_table (
+  id int8,
+  name text,
+  status user_status
+) server foreign_server options (schema_name 'public', table_name 'users');

test/lib/foreign-tables.ts

@@ -0,0 +1,78 @@
+import { pgMeta } from './utils'
+
+test('list', async () => {
+  const res = await pgMeta.foreignTables.list()
+  expect(res.data?.find(({ name }) => name === 'foreign_table')).toMatchInlineSnapshot(
+    { id: expect.any(Number) },
+    `
+    Object {
+      "columns": Array [
+        Object {
+          "comment": null,
+          "data_type": "bigint",
+          "default_value": null,
+          "enums": Array [],
+          "format": "int8",
+          "id": "16434.1",
+          "identity_generation": null,
+          "is_generated": false,
+          "is_identity": false,
+          "is_nullable": true,
+          "is_unique": false,
+          "is_updatable": true,
+          "name": "id",
+          "ordinal_position": 1,
+          "schema": "public",
+          "table": "foreign_table",
+          "table_id": 16434,
+        },
+        Object {
+          "comment": null,
+          "data_type": "text",
+          "default_value": null,
+          "enums": Array [],
+          "format": "text",
+          "id": "16434.2",
+          "identity_generation": null,
+          "is_generated": false,
+          "is_identity": false,
+          "is_nullable": true,
+          "is_unique": false,
+          "is_updatable": true,
+          "name": "name",
+          "ordinal_position": 2,
+          "schema": "public",
+          "table": "foreign_table",
+          "table_id": 16434,
+        },
+        Object {
+          "comment": null,
+          "data_type": "USER-DEFINED",
+          "default_value": null,
+          "enums": Array [
+            "ACTIVE",
+            "INACTIVE",
+          ],
+          "format": "user_status",
+          "id": "16434.3",
+          "identity_generation": null,
+          "is_generated": false,
+          "is_identity": false,
+          "is_nullable": true,
+          "is_unique": false,
+          "is_updatable": true,
+          "name": "status",
+          "ordinal_position": 3,
+          "schema": "public",
+          "table": "foreign_table",
+          "table_id": 16434,
+        },
+      ],
+      "comment": null,
+      "id": Any<Number>,
+      "name": "foreign_table",
+      "schema": "public",
+    }
+  `
+  )
+})

test/lib/index.test.ts

@@ -14,3 +14,4 @@ import './policies'
 import './publications'
 import './triggers'
 import './views'
+import './foreign-tables'