feat: materialized views

Author: soedirgo

src/lib/PostgresMeta.ts

@@ -5,6 +5,7 @@ import PostgresMetaConfig from './PostgresMetaConfig.js'
 import PostgresMetaExtensions from './PostgresMetaExtensions.js'
 import PostgresMetaForeignTables from './PostgresMetaForeignTables.js'
 import PostgresMetaFunctions from './PostgresMetaFunctions.js'
+import PostgresMetaMaterializedViews from './PostgresMetaMaterializedViews.js'
 import PostgresMetaPolicies from './PostgresMetaPolicies.js'
 import PostgresMetaPublications from './PostgresMetaPublications.js'
 import PostgresMetaRoles from './PostgresMetaRoles.js'
@@ -25,6 +26,7 @@ export default class PostgresMeta {
   extensions: PostgresMetaExtensions
   foreignTables: PostgresMetaForeignTables
   functions: PostgresMetaFunctions
+  materializedViews: PostgresMetaMaterializedViews
   policies: PostgresMetaPolicies
   publications: PostgresMetaPublications
   roles: PostgresMetaRoles
@@ -48,6 +50,7 @@ export default class PostgresMeta {
     this.extensions = new PostgresMetaExtensions(this.query)
     this.foreignTables = new PostgresMetaForeignTables(this.query)
     this.functions = new PostgresMetaFunctions(this.query)
+    this.materializedViews = new PostgresMetaMaterializedViews(this.query)
     this.policies = new PostgresMetaPolicies(this.query)
     this.publications = new PostgresMetaPublications(this.query)
     this.roles = new PostgresMetaRoles(this.query)

src/lib/PostgresMetaMaterializedViews.ts

@@ -0,0 +1,117 @@
+import { literal } from 'pg-format'
+import { coalesceRowsToArray, filterByList } from './helpers.js'
+import { columnsSql, materializedViewsSql } from './sql/index.js'
+import { PostgresMetaResult, PostgresMaterializedView } from './types.js'
+
+export default class PostgresMetaMaterializedViews {
+  query: (sql: string) => Promise<PostgresMetaResult<any>>
+
+  constructor(query: (sql: string) => Promise<PostgresMetaResult<any>>) {
+    this.query = query
+  }
+
+  async list(options: {
+    includedSchemas?: string[]
+    excludedSchemas?: string[]
+    limit?: number
+    offset?: number
+    includeColumns: true
+  }): Promise<PostgresMetaResult<(PostgresMaterializedView & { columns: unknown[] })[]>>
+  async list(options?: {
+    includedSchemas?: string[]
+    excludedSchemas?: string[]
+    limit?: number
+    offset?: number
+    includeColumns?: boolean
+  }): Promise<PostgresMetaResult<(PostgresMaterializedView & { columns: never })[]>>
+  async list({
+    includedSchemas,
+    excludedSchemas,
+    limit,
+    offset,
+    includeColumns = false,
+  }: {
+    includedSchemas?: string[]
+    excludedSchemas?: string[]
+    limit?: number
+    offset?: number
+    includeColumns?: boolean
+  } = {}): Promise<PostgresMetaResult<PostgresMaterializedView[]>> {
+    let sql = generateEnrichedMaterializedViewsSql({ includeColumns })
+    const filter = filterByList(includedSchemas, excludedSchemas, undefined)
+    if (filter) {
+      sql += ` where schema ${filter}`
+    }
+    if (limit) {
+      sql += ` limit ${limit}`
+    }
+    if (offset) {
+      sql += ` offset ${offset}`
+    }
+    return await this.query(sql)
+  }
+
+  async retrieve({ id }: { id: number }): Promise<PostgresMetaResult<PostgresMaterializedView>>
+  async retrieve({
+    name,
+    schema,
+  }: {
+    name: string
+    schema: string
+  }): Promise<PostgresMetaResult<PostgresMaterializedView>>
+  async retrieve({
+    id,
+    name,
+    schema = 'public',
+  }: {
+    id?: number
+    name?: string
+    schema?: string
+  }): Promise<PostgresMetaResult<PostgresMaterializedView>> {
+    if (id) {
+      const sql = `${generateEnrichedMaterializedViewsSql({
+        includeColumns: true,
+      })} where materialized_views.id = ${literal(id)};`
+      console.log(sql)
+      const { data, error } = await this.query(sql)
+      if (error) {
+        return { data, error }
+      } else if (data.length === 0) {
+        return { data: null, error: { message: `Cannot find a materialized view with ID ${id}` } }
+      } else {
+        return { data: data[0], error }
+      }
+    } else if (name) {
+      const sql = `${generateEnrichedMaterializedViewsSql({
+        includeColumns: true,
+      })} where materialized_views.name = ${literal(
+        name
+      )} and materialized_views.schema = ${literal(schema)};`
+      const { data, error } = await this.query(sql)
+      if (error) {
+        return { data, error }
+      } else if (data.length === 0) {
+        return {
+          data: null,
+          error: { message: `Cannot find a materialized view named ${name} in schema ${schema}` },
+        }
+      } else {
+        return { data: data[0], error }
+      }
+    } else {
+      return { data: null, error: { message: 'Invalid parameters on materialized view retrieve' } }
+    }
+  }
+}
+
+const generateEnrichedMaterializedViewsSql = ({ includeColumns }: { includeColumns: boolean }) => `
+with materialized_views as (${materializedViewsSql})
+  ${includeColumns ? `, columns as (${columnsSql})` : ''}
+select
+  *
+  ${
+    includeColumns
+      ? `, ${coalesceRowsToArray('columns', 'columns.table_id = materialized_views.id')}`
+      : ''
+  }
+from materialized_views`

src/lib/index.ts

@@ -8,6 +8,7 @@ export {
   PostgresExtension,
   PostgresFunction,
   PostgresFunctionCreate,
+  PostgresMaterializedView,
   PostgresPolicy,
   PostgresPrimaryKey,
   PostgresPublication,

src/lib/sql/columns.sql

@@ -85,7 +85,7 @@ WHERE
   NOT pg_is_other_temp_schema(nc.oid)
   AND a.attnum > 0
   AND NOT a.attisdropped
-  AND (c.relkind IN ('r', 'v', 'f', 'p'))
+  AND (c.relkind IN ('r', 'v', 'm', 'f', 'p'))
   AND (
     pg_has_role(c.relowner, 'USAGE')
     OR has_column_privilege(

src/lib/sql/index.ts

@@ -8,6 +8,10 @@ export const configSql = await readFile(join(__dirname, 'config.sql'), 'utf-8')
 export const extensionsSql = await readFile(join(__dirname, 'extensions.sql'), 'utf-8')
 export const foreignTablesSql = await readFile(join(__dirname, 'foreign_tables.sql'), 'utf-8')
 export const functionsSql = await readFile(join(__dirname, 'functions.sql'), 'utf-8')
+export const materializedViewsSql = await readFile(
+  join(__dirname, 'materialized_views.sql'),
+  'utf-8'
+)
 export const policiesSql = await readFile(join(__dirname, 'policies.sql'), 'utf-8')
 export const primaryKeysSql = await readFile(join(__dirname, 'primary_keys.sql'), 'utf-8')
 export const publicationsSql = await readFile(join(__dirname, 'publications.sql'), 'utf-8')

src/lib/sql/materialized_views.sql

@@ -0,0 +1,11 @@
+select
+  c.oid::int8 as id,
+  n.nspname as schema,
+  c.relname as name,
+  c.relispopulated as is_populated,
+  obj_description(c.oid) as comment
+from
+  pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+where
+  c.relkind = 'm'

src/lib/types.ts

@@ -384,3 +384,13 @@ export const postgresViewSchema = Type.Object({
   columns: Type.Optional(Type.Array(postgresColumnSchema)),
 })
 export type PostgresView = Static<typeof postgresViewSchema>
+
+export const postgresMaterializedViewSchema = Type.Object({
+  id: Type.Integer(),
+  schema: Type.String(),
+  name: Type.String(),
+  is_populated: Type.Boolean(),
+  comment: Type.Union([Type.String(), Type.Null()]),
+  columns: Type.Optional(Type.Array(postgresColumnSchema)),
+})
+export type PostgresMaterializedView = Static<typeof postgresMaterializedViewSchema>

src/server/routes/index.ts

@@ -5,6 +5,7 @@ import ConfigRoute from './config.js'
 import ExtensionsRoute from './extensions.js'
 import ForeignTablesRoute from './foreign-tables.js'
 import FunctionsRoute from './functions.js'
+import MaterializedViewsRoute from './materialized-views.js'
 import PoliciesRoute from './policies.js'
 import PublicationsRoute from './publications.js'
 import QueryRoute from './query.js'
@@ -45,6 +46,7 @@ export default async (fastify: FastifyInstance) => {
   fastify.register(ExtensionsRoute, { prefix: '/extensions' })
   fastify.register(ForeignTablesRoute, { prefix: '/foreign-tables' })
   fastify.register(FunctionsRoute, { prefix: '/functions' })
+  fastify.register(MaterializedViewsRoute, { prefix: '/materialized-views' })
   fastify.register(PoliciesRoute, { prefix: '/policies' })
   fastify.register(PublicationsRoute, { prefix: '/publications' })
   fastify.register(QueryRoute, { prefix: '/query' })

src/server/routes/materialized-views.ts

@@ -0,0 +1,93 @@
+import { FastifyPluginAsyncTypebox } from '@fastify/type-provider-typebox'
+import { Type } from '@sinclair/typebox'
+import { PostgresMeta } from '../../lib/index.js'
+import { postgresMaterializedViewSchema } from '../../lib/types.js'
+import { DEFAULT_POOL_CONFIG } from '../constants.js'
+import { extractRequestForLogging } from '../utils.js'
+
+const route: FastifyPluginAsyncTypebox = async (fastify) => {
+  fastify.get(
+    '/',
+    {
+      schema: {
+        headers: Type.Object({
+          pg: Type.String(),
+        }),
+        querystring: Type.Object({
+          included_schemas: Type.Optional(Type.String()),
+          excluded_schemas: Type.Optional(Type.String()),
+          limit: Type.Optional(Type.Integer()),
+          offset: Type.Optional(Type.Integer()),
+          include_columns: Type.Optional(Type.Boolean()),
+        }),
+        response: {
+          200: Type.Array(postgresMaterializedViewSchema),
+          500: Type.Object({
+            error: Type.String(),
+          }),
+        },
+      },
+    },
+    async (request, reply) => {
+      const connectionString = request.headers.pg
+      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 includeColumns = request.query.include_columns
+
+      const pgMeta = new PostgresMeta({ ...DEFAULT_POOL_CONFIG, connectionString })
+      const { data, error } = await pgMeta.materializedViews.list({
+        includedSchemas,
+        excludedSchemas,
+        limit,
+        offset,
+        includeColumns,
+      })
+      await pgMeta.end()
+      if (error) {
+        request.log.error({ error, request: extractRequestForLogging(request) })
+        reply.code(500)
+        return { error: error.message }
+      }
+
+      return data
+    }
+  )
+
+  fastify.get(
+    '/:id(\\d+)',
+    {
+      schema: {
+        headers: Type.Object({
+          pg: Type.String(),
+        }),
+        params: Type.Object({
+          id: Type.Integer(),
+        }),
+        response: {
+          200: postgresMaterializedViewSchema,
+          404: Type.Object({
+            error: Type.String(),
+          }),
+        },
+      },
+    },
+    async (request, reply) => {
+      const connectionString = request.headers.pg
+      const id = request.params.id
+
+      const pgMeta = new PostgresMeta({ ...DEFAULT_POOL_CONFIG, connectionString })
+      const { data, error } = await pgMeta.materializedViews.retrieve({ id })
+      await pgMeta.end()
+      if (error) {
+        request.log.error({ error, request: extractRequestForLogging(request) })
+        reply.code(404)
+        return { error: error.message }
+      }
+
+      return data
+    }
+  )
+}
+export default route