feat(/functions): adds POST /functions and DELETE /functions

implements missing routes and (POST & DELETE)

#115

Author: i-pip

src/lib/PostgresMetaFunctions.ts

@@ -1,4 +1,4 @@
-import { literal } from 'pg-format'
+import { ident, literal } from 'pg-format'
 import { DEFAULT_SYSTEM_SCHEMAS } from './constants'
 import { functionsSql } from './sql'
 import { PostgresMetaResult, PostgresFunction } from './types'
@@ -22,7 +22,13 @@ export default class PostgresMetaFunctions {
   }
 
   async retrieve({ id }: { id: number }): Promise<PostgresMetaResult<PostgresFunction>>
-  async retrieve({ name }: { name: string }): Promise<PostgresMetaResult<PostgresFunction>>
+  async retrieve({
+    name,
+    schema,
+  }: {
+    name: string
+    schema: string
+  }): Promise<PostgresMetaResult<PostgresFunction>>
   async retrieve({
     id,
     name,
@@ -57,4 +63,54 @@ export default class PostgresMetaFunctions {
       return { data: null, error: { message: 'Invalid parameters on function retrieve' } }
     }
   }
+
+  async create({
+    name,
+    schema = 'public',
+    params,
+    definition,
+    rettype = 'void',
+    language = 'sql',
+  }: {
+    name: string
+    schema?: string
+    params?: string[]
+    definition: string
+    rettype?: string
+    language?: string
+  }): Promise<PostgresMetaResult<PostgresFunction>> {
+    const sql = `
+      CREATE FUNCTION ${ident(schema)}.${ident(name)}
+      ${params && params.length ? `(${params.join(',')})` : '()'}
+      RETURNS ${rettype || 'void'}
+      AS '${definition}'
+      LANGUAGE ${language}
+      RETURNS NULL ON NULL INPUT;
+      `
+    const { error } = await this.query(sql)
+    if (error) {
+      return { data: null, error }
+    }
+    return await this.retrieve({ name, schema })
+  }
+
+  async remove(
+    id: number,
+    { cascade = false } = {}
+  ): Promise<PostgresMetaResult<PostgresFunction>> {
+    const { data: func, error } = await this.retrieve({ id })
+    if (error) {
+      return { data: null, error }
+    }
+    const sql = `DROP FUNCTION ${ident(func!.schema)}.${ident(func!.name)} ${
+      cascade ? 'CASCADE' : 'RESTRICT'
+    };`
+    {
+      const { error } = await this.query(sql)
+      if (error) {
+        return { data: null, error }
+      }
+    }
+    return { data: func!, error: null }
+  }
 }

src/server/routes/functions.ts

@@ -43,4 +43,42 @@ export default async (fastify: FastifyInstance) => {
 
     return data
   })
+
+  fastify.post<{
+    Headers: { pg: string }
+    Body: any
+  }>('/', async (request, reply) => {
+    const connectionString = request.headers.pg
+
+    const pgMeta = new PostgresMeta({ connectionString, max: 1 })
+    const { data, error } = await pgMeta.functions.create(request.body)
+    await pgMeta.end()
+    if (error) {
+      request.log.error(JSON.stringify({ error, req: request.body }))
+      reply.code(400)
+      return { error: error.message }
+    }
+    return data
+  })
+
+  fastify.delete<{
+    Headers: { pg: string }
+    Params: {
+      id: string
+    }
+  }>('/:id(\\d+)', async (request, reply) => {
+    const connectionString = request.headers.pg
+    const id = Number(request.params.id)
+
+    const pgMeta = new PostgresMeta({ connectionString, max: 1 })
+    const { data, error } = await pgMeta.functions.remove(id)
+    await pgMeta.end()
+    if (error) {
+      request.log.error(JSON.stringify({ error, req: request.body }))
+      reply.code(400)
+      if (error.message.startsWith('Cannot find')) reply.code(404)
+      return { error: error.message }
+    }
+    return data
+  })
 }

test/integration/index.spec.js

@@ -157,6 +157,20 @@ describe('/types', () => {
   })
 })
 describe('/functions', () => {
+  var func = {
+    id: null,
+    name: 'test_func',
+    schema: 'public',
+    params: ['integer', 'integer'],
+    definition: 'select $1 + $2',
+    rettype: 'integer',
+    language: 'sql',
+  }
+  before(async () => {
+    await axios.post(`${URL}/query`, {
+      query: `DROP FUNCTION IF EXISTS "${func.name}";`,
+    })
+  })
   it('GET', async () => {
     const res = await axios.get(`${URL}/functions`)
     // console.log('res.data', res.data)
@@ -184,7 +198,22 @@ describe('/functions', () => {
 
     assert.deepStrictEqual(functionById, functionFiltered)
   })
+  it('POST', async () => {
+    const { data: newFunc } = await axios.post(`${URL}/functions`, func)
+    assert.equal(newFunc.name, 'test_func')
+    assert.equal(newFunc.schema, 'public')
+    assert.equal(newFunc.language, 'sql')
+    assert.equal(newFunc.return_type, 'int4')
+    func.id = newFunc.id
+  })
+  it('DELETE', async () => {
+    await axios.delete(`${URL}/functions/${func.id}`)
+    const { data: functions } = await axios.get(`${URL}/functions`)
+    const stillExists = functions.some((x) => func.id === x.id)
+    assert.equal(stillExists, false, 'Function is deleted')
+  })
 })
+
 describe('/tables', async () => {
   it('GET', async () => {
     const tables = await axios.get(`${URL}/tables`)