Merge branch 'develop' into feature/modify_tables

Author: soedirgo

src/api.ts

@@ -7,6 +7,7 @@ router.use(cors())
 router.use('/config', addConnectionToRequest, require('./api/config'))
 router.use('/columns', addConnectionToRequest, require('./api/columns'))
 router.use('/extensions', addConnectionToRequest, require('./api/extensions'))
+router.use('/functions', addConnectionToRequest, require('./api/functions'))
 router.use('/query', addConnectionToRequest, require('./api/query'))
 router.use('/schemas', addConnectionToRequest, require('./api/schemas'))
 router.use('/tables', addConnectionToRequest, require('./api/tables'))

src/api/functions.ts

@@ -0,0 +1,40 @@
+import { Router } from 'express'
+
+import sql = require('../lib/sql')
+const { functions } = sql
+import { RunQuery } from '../lib/connectionPool'
+import { DEFAULT_SYSTEM_SCHEMAS } from '../lib/constants'
+import { Functions } from '../lib/interfaces'
+
+const router = Router()
+router.get('/', async (req, res) => {
+  try {
+    const { data } = await RunQuery(req.headers.pg, functions)
+    const query: Fetch.QueryParams = req.query
+    let payload: Functions.Function[] = data
+    if (!query?.includeSystemSchemas) payload = removeSystemSchemas(data)
+    return res.status(200).json(payload)
+  } catch (error) {
+    console.log('throwing error')
+    res.status(500).json({ error: 'Database error', status: 500 })
+  }
+})
+
+const removeSystemSchemas = (data: Functions.Function[]) => {
+  return data.filter((x) => !DEFAULT_SYSTEM_SCHEMAS.includes(x.schema))
+}
+
+export = router
+
+/**
+ * Types
+ */
+
+namespace Fetch {
+  /**
+   * @param {boolean} [includeSystemSchemas=false] - Return system schemas as well as user schemas
+   */
+  export interface QueryParams {
+    includeSystemSchemas?: boolean
+  }
+}

src/api/tables.ts

@@ -1,7 +1,7 @@
 import { Router } from 'express'
 import SQL from 'sql-template-strings'
 import sqlTemplates = require('../lib/sql')
-const { columns, grants, primary_keys, relationships, tables } = sqlTemplates
+const { columns, grants, policies, primary_keys, relationships, tables } = sqlTemplates
 import { coalesceRowsToArray } from '../lib/helpers'
 import { RunQuery } from '../lib/connectionPool'
 import { DEFAULT_SYSTEM_SCHEMAS } from '../lib/constants'
@@ -15,12 +15,14 @@ router.get('/', async (req, res) => {
 WITH tables AS ( ${tables} ),
   columns AS ( ${columns} ),
   grants AS ( ${grants} ),
+  policies AS ( ${policies} ),
   primary_keys AS ( ${primary_keys} ),
   relationships AS ( ${relationships} )
 SELECT
   *,
   ${coalesceRowsToArray('columns', 'SELECT * FROM columns WHERE columns.table_id = tables.id')},
   ${coalesceRowsToArray('grants', 'SELECT * FROM grants WHERE grants.table_id = tables.id')},
+  ${coalesceRowsToArray('policies', 'SELECT * FROM policies WHERE policies.table_id = tables.id')},
   ${coalesceRowsToArray(
     'primary_keys',
     'SELECT * FROM primary_keys WHERE primary_keys.table_id = tables.id'

src/lib/interfaces.ts

@@ -30,6 +30,18 @@ export namespace Roles {
   }
 }
 
+export namespace Functions {
+  export interface Function {
+    id: number
+    schema: string
+    name: string
+    language: string
+    definition: string
+    argument_types: string
+    return_type: string
+  }
+}
+
 export namespace Schemas {
   export interface Schema {
     id: number
@@ -98,6 +110,18 @@ export namespace Tables {
     is_updatable: boolean
   }
 
+  export interface Policy {
+    id: number
+    schema: string
+    table: string
+    table_id: number
+    permissive: boolean
+    roles: string[]
+    cmd: string
+    definition: string
+    with_check: string
+  }
+
   export interface PrimaryKey {
     schema: string
     table_name: string

src/lib/sql/extensions_enabled.sql

@@ -0,0 +1,16 @@
+select
+    p.oid as id,
+    n.nspname as schema,
+    p.proname as name,
+    l.lanname as language,
+    case
+        when l.lanname = 'internal' then p.prosrc
+        else pg_get_functiondef(p.oid)
+    end as definition,
+    pg_get_function_arguments(p.oid) as argument_types,
+    t.typname as return_type
+from
+    pg_proc p
+    left join pg_namespace n on p.pronamespace = n.oid
+    left join pg_language l on p.prolang = l.oid
+    left join pg_type t on t.oid = p.prorettype

src/lib/sql/functions.sql

@@ -6,6 +6,7 @@ export = {
   config: fs.readFileSync(path.join(__dirname, '/config.sql')).toString(),
   constraints: fs.readFileSync(path.join(__dirname, '/constraints.sql')).toString(),
   extensions: fs.readFileSync(path.join(__dirname, '/extensions.sql')).toString(),
+  functions: fs.readFileSync(path.join(__dirname, '/functions.sql')).toString(),
   grants: fs.readFileSync(path.join(__dirname, '/grants.sql')).toString(),
   joins: fs.readFileSync(path.join(__dirname, '/joins.sql')).toString(),
   primary_keys: fs.readFileSync(path.join(__dirname, '/primary_keys.sql')).toString(),

src/lib/sql/index.ts

@@ -1,14 +1,17 @@
-SELECT
-  n.nspname AS schemaname,
-  c.relname AS tablename,
-  pol.polname AS policyname,
+select
+  n.oid as id,
+  n.nspname AS schema,
+  c.relname AS table,
+  c.oid AS table_id,
+  pol.polname AS name,
   CASE
     WHEN pol.polpermissive THEN 'PERMISSIVE' :: text
     ELSE 'RESTRICTIVE' :: text
   END AS permissive,
   CASE
-    WHEN pol.polroles = '{0}' :: oid [] THEN string_to_array('public' :: text, '' :: text) :: name []
-    ELSE ARRAY(
+    WHEN pol.polroles = '{0}' :: oid [] 
+    THEN array_to_json(string_to_array('public' :: text, '' :: text) :: name [])
+    ELSE array_to_json(ARRAY(
       SELECT
         pg_authid.rolname
       FROM
@@ -17,7 +20,7 @@ SELECT
         pg_authid.oid = ANY (pol.polroles)
       ORDER BY
         pg_authid.rolname
-    )
+    ))
   END AS roles,
   CASE
     pol.polcmd
@@ -33,4 +36,4 @@ SELECT
 FROM
   pg_policy pol
   JOIN pg_class c ON c.oid = pol.polrelid
-  LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+  LEFT JOIN pg_namespace n ON n.oid = c.relnamespace

src/lib/sql/policies.sql

@@ -141,16 +141,36 @@ describe('/types', () => {
     assert.equal(true, !!included)
   })
 })
-describe('/tables & /columns', async () => {
-  it('GET /tables', async () => {
+describe('/functions', () => {
+  it('GET', async () => {
+    const res = await axios.get(`${URL}/functions`)
+    // console.log('res.data', res.data)
+    const datum = res.data.find((x) => x.schema == 'public')
+    const notIncluded = res.data.find((x) => x.schema == 'pg_toast')
+    assert.equal(res.status, STATUS.SUCCESS)
+    assert.equal(true, !!datum)
+    assert.equal(true, !notIncluded)
+  })
+  it('GET with system functions', async () => {
+    const res = await axios.get(`${URL}/functions?includeSystemSchemas=true`)
+    // console.log('res.data', res.data)
+    const datum = res.data.find((x) => x.schema == 'public')
+    const included = res.data.find((x) => x.schema == 'pg_catalog')
+    assert.equal(res.status, STATUS.SUCCESS)
+    assert.equal(true, !!datum)
+    assert.equal(true, !!included)
+  })
+})
+describe('/tables', async () => {
+  it('GET', async () => {
     const tables = await axios.get(`${URL}/tables`)
     const datum = tables.data.find((x) => `${x.schema}.${x.name}` === 'public.users')
     const notIncluded = tables.data.find((x) => `${x.schema}.${x.name}` === 'pg_catalog.pg_type')
     assert.equal(tables.status, STATUS.SUCCESS)
     assert.equal(true, !!datum)
     assert.equal(true, !notIncluded)
   })
-  it('/tables should return the columns', async () => {
+  it('should return the columns, grants, and policies', async () => {
     const tables = await axios.get(`${URL}/tables`)
     const datum = tables.data.find((x) => `${x.schema}.${x.name}` === 'public.users')
     const idColumn = datum.columns.find((x) => x.name === 'id')
@@ -161,11 +181,8 @@ describe('/tables & /columns', async () => {
     assert.equal(idColumn.is_updatable, true)
     assert.equal(idColumn.is_identity, true)
     assert.equal(nameColumn.is_identity, false)
-  })
-  it('/tables should return the grants', async () => {
-    const tables = await axios.get(`${URL}/tables`)
-    const datum = tables.data.find((x) => `${x.schema}.${x.name}` === 'public.users')
     assert.equal(datum.grants.length > 0, true)
+    assert.equal(datum.policies.length == 0, true)
   })
   it('/tables should return the relationships', async () => {
     const tables = await axios.get(`${URL}/tables`)

test/integration/index.spec.js

@@ -25,3 +25,10 @@ INSERT INTO
 VALUES 
     ('Star the repo', 1),
     ('Watch the releases', 2);
+
+
+CREATE FUNCTION add(integer, integer) RETURNS integer
+    AS 'select $1 + $2;'
+    LANGUAGE SQL
+    IMMUTABLE
+    RETURNS NULL ON NULL INPUT;

test/postgres/mnt/00-init.sql

@@ -1,8 +1,20 @@
+
+
 CREATE TABLE public.category (
 	id serial NOT NULL PRIMARY KEY,
 	name text NOT NULL
 );
 
+-- Fake policies
+grant select, update(name)
+on category
+to postgres;
+
+create policy categories_update_policy
+on category for update 
+to postgres
+using(current_setting('my.username') IN (name));
+
 INSERT INTO public.category (id, name) VALUES
 (1, 'Funny'),
 (2, 'Weird'),