fix(typegen): array types in fn args

Author: soedirgo

src/server/app.ts

@@ -69,6 +69,7 @@ if (EXPORT_DOCS) {
     const { data: views, error: viewsError } = await pgMeta.views.list()
     const { data: functions, error: functionsError } = await pgMeta.functions.list()
     const { data: types, error: typesError } = await pgMeta.types.list({
+      includeArrayTypes: true,
       includeSystemSchemas: true,
     })
     await pgMeta.end()
@@ -101,7 +102,8 @@ if (EXPORT_DOCS) {
         functions: functions.filter(
           ({ return_type }) => !['trigger', 'event_trigger'].includes(return_type)
         ),
-        types,
+        types: types.filter(({ name }) => name[0] !== '_'),
+        arrayTypes: types.filter(({ name }) => name[0] === '_'),
       })
     )
   })()

src/server/routes/generators/typescript.ts

@@ -24,6 +24,7 @@ export default async (fastify: FastifyInstance) => {
     const { data: views, error: viewsError } = await pgMeta.views.list()
     const { data: functions, error: functionsError } = await pgMeta.functions.list()
     const { data: types, error: typesError } = await pgMeta.types.list({
+      includeArrayTypes: true,
       includeSystemSchemas: true,
     })
     await pgMeta.end()
@@ -65,7 +66,8 @@ export default async (fastify: FastifyInstance) => {
       functions: functions.filter(
         ({ return_type }) => !['trigger', 'event_trigger'].includes(return_type)
       ),
-      types,
+      types: types.filter(({ name }) => name[0] !== '_'),
+      arrayTypes: types.filter(({ name }) => name[0] === '_'),
     })
   })
 }

src/server/templates/typescript.ts

@@ -13,12 +13,14 @@ export const apply = ({
   views,
   functions,
   types,
+  arrayTypes,
 }: {
   schemas: PostgresSchema[]
   tables: PostgresTable[]
   views: PostgresView[]
   functions: PostgresFunction[]
   types: PostgresType[]
+  arrayTypes: PostgresType[]
 }): string => {
   let output = `
 export type Json = string | number | boolean | null | { [key: string]: Json } | Json[]
@@ -214,11 +216,20 @@ export interface Database {
                     }
 
                     const argsNameAndType = inArgs.map(({ name, type_id }) => {
-                      const type = types.find(({ id }) => id === type_id)
-                      if (!type) {
-                        return { name, type: 'unknown' }
+                      let type = arrayTypes.find(({ id }) => id === type_id)
+                      if (type) {
+                        // If it's an array type, the name looks like `_int8`.
+                        const elementTypeName = type.name.substring(1)
+                        return {
+                          name,
+                          type: `(${pgTypeToTsType(elementTypeName, types, schemas)})[]`,
+                        }
+                      }
+                      type = types.find(({ id }) => id === type_id)
+                      if (type) {
+                        return { name, type: pgTypeToTsType(type.name, types, schemas) }
                       }
-                      return { name, type: pgTypeToTsType(type.name, types, schemas) }
+                      return { name, type: 'unknown' }
                     })
 
                     return `{ ${argsNameAndType.map(
@@ -230,11 +241,20 @@ export interface Database {
 
                     if (tableArgs.length > 0) {
                       const argsNameAndType = tableArgs.map(({ name, type_id }) => {
-                        const type = types.find(({ id }) => id === type_id)
-                        if (!type) {
-                          return { name, type: 'unknown' }
+                        let type = arrayTypes.find(({ id }) => id === type_id)
+                        if (type) {
+                          // If it's an array type, the name looks like `_int8`.
+                          const elementTypeName = type.name.substring(1)
+                          return {
+                            name,
+                            type: `(${pgTypeToTsType(elementTypeName, types, schemas)})[]`,
+                          }
                         }
-                        return { name, type: pgTypeToTsType(type.name, types, schemas) }
+                        type = types.find(({ id }) => id === type_id)
+                        if (type) {
+                          return { name, type: pgTypeToTsType(type.name, types, schemas) }
+                        }
+                        return { name, type: 'unknown' }
                       })
 
                       return `{ ${argsNameAndType.map(