refactor: convert FunctionInputs to PostgresFunctionCreate

Author: w3b6x9

package-lock.json

@@ -26,7 +26,7 @@
     "test": "run-s build:server && node -r esm ./node_modules/.bin/mocha 'test/**/*.js' --recursive"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.16.7",
+    "@sinclair/typebox": "^0.19.2",
     "pg": "^7.0.0",
     "pg-format": "^1.0.4"
   },

package.json

@@ -1,19 +1,7 @@
 import { ident, literal } from 'pg-format'
 import { DEFAULT_SYSTEM_SCHEMAS } from './constants'
 import { functionsSql } from './sql'
-import { PostgresMetaResult, PostgresFunction } from './types'
-
-type FunctionInputs = {
-  name: string
-  definition: string
-  args?: string[]
-  behavior?: 'IMMUTABLE' | 'STABLE' | 'VOLATILE'
-  config_params?: { [key: string]: string }
-  schema?: string
-  language?: string
-  return_type?: string
-  security_definer?: boolean
-}
+import { PostgresMetaResult, PostgresFunction, PostgresFunctionCreate } from './types'
 
 export default class PostgresMetaFunctions {
   query: (sql: string) => Promise<PostgresMetaResult<any>>
@@ -94,7 +82,7 @@ export default class PostgresMetaFunctions {
     behavior = 'VOLATILE',
     security_definer = false,
     config_params = {},
-  }: FunctionInputs): Promise<PostgresMetaResult<PostgresFunction>> {
+  }: PostgresFunctionCreate): Promise<PostgresMetaResult<PostgresFunction>> {
     const sql = this.generateCreateFunctionSql({
       name,
       schema,
@@ -130,19 +118,26 @@ export default class PostgresMetaFunctions {
       return { data: null, error }
     }
 
-    const updateDefinitionSql = typeof definition === 'string' ? this.generateCreateFunctionSql(
-      { ...currentFunc!, definition },
-      { replace: true }
-    ) : ''
+    const args = currentFunc!.argument_types.split(', ')
 
-    const retrieveFunctionSql = this.generateRetrieveFunctionSql(
-      {
-        schema: currentFunc!.schema,
-        name: currentFunc!.name,
-        args: currentFunc!.argument_types.split(', '),
-      },
-      { terminateCommand: false }
-    )
+    const updateDefinitionSql =
+      typeof definition === 'string'
+        ? this.generateCreateFunctionSql(
+            {
+              ...currentFunc!,
+              definition,
+              args,
+              config_params: currentFunc!.config_params ?? {},
+            },
+            { replace: true }
+          )
+        : ''
+
+    const retrieveFunctionSql = this.generateRetrieveFunctionSql({
+      schema: currentFunc!.schema,
+      name: currentFunc!.name,
+      args,
+    })
 
     const updateNameSql =
       name && name !== currentFunc!.name
@@ -218,19 +213,18 @@ export default class PostgresMetaFunctions {
       name,
       schema,
       args,
-      argument_types,
       definition,
       return_type,
       language,
       behavior,
       security_definer,
       config_params,
-    }: Partial<Omit<FunctionInputs, 'config_params'> & PostgresFunction>,
-    { replace = false, terminateCommand = true } = {}
+    }: PostgresFunctionCreate,
+    { replace = false } = {}
   ): string {
     return `
       CREATE ${replace ? 'OR REPLACE' : ''} FUNCTION ${ident(schema!)}.${ident(name!)}(${
-      argument_types || args?.join(', ') || ''
+      args?.join(', ') || ''
     })
       RETURNS ${return_type}
       AS ${literal(definition)}
@@ -247,23 +241,19 @@ export default class PostgresMetaFunctions {
               )
               .join('\n')
           : ''
-      }
-      ${terminateCommand ? ';' : ''}
+      };
     `
   }
 
-  private generateRetrieveFunctionSql(
-    {
-      schema,
-      name,
-      args,
-    }: {
-      schema: string
-      name: string
-      args: string[]
-    },
-    { terminateCommand = true } = {}
-  ): string {
+  private generateRetrieveFunctionSql({
+    schema,
+    name,
+    args,
+  }: {
+    schema: string
+    name: string
+    args: string[]
+  }): string {
     return `${enrichedFunctionsSql} JOIN pg_proc AS p ON id = p.oid WHERE schema = ${literal(
       schema
     )} AND name = ${literal(name)} AND p.proargtypes::text = ${
@@ -286,7 +276,7 @@ export default class PostgresMetaFunctions {
               ) AS arr
             ) AS split_args
           ) args
-    ) ${terminateCommand ? ';' : ''}`
+    )`
         : literal('')
     }`
   }

src/lib/PostgresMetaFunctions.ts

@@ -85,10 +85,25 @@ const postgresFunctionSchema = Type.Object({
     Type.Literal('VOLATILE'),
   ]),
   security_definer: Type.Boolean(),
-  config_params: Type.Union([Type.Dict(Type.String()), Type.Null()]),
+  config_params: Type.Union([Type.Record(Type.String(), Type.String()), Type.Null()]),
 })
 export type PostgresFunction = Static<typeof postgresFunctionSchema>
 
+export const postgresFunctionCreateFunction = Type.Object({
+  name: Type.String(),
+  definition: Type.String(),
+  args: Type.Optional(Type.Array(Type.String())),
+  behavior: Type.Optional(
+    Type.Union([Type.Literal('IMMUTABLE'), Type.Literal('STABLE'), Type.Literal('VOLATILE')])
+  ),
+  config_params: Type.Optional(Type.Record(Type.String(), Type.String())),
+  schema: Type.Optional(Type.String()),
+  language: Type.Optional(Type.String()),
+  return_type: Type.Optional(Type.String()),
+  security_definer: Type.Optional(Type.Boolean()),
+})
+export type PostgresFunctionCreate = Static<typeof postgresFunctionCreateFunction>
+
 export const postgresGrantSchema = Type.Object({
   table_id: Type.Integer(),
   grantor: Type.String(),