Fix nullable elements in PG Arrays (::text[], ::int[]...)

packages/cli/src/generator.test.ts

@@ -799,6 +799,73 @@ export interface IGetNotificationsResult {
 export interface IGetNotificationsQuery {
   params: IGetNotificationsParams;
   result: IGetNotificationsResult;
+}\n\n`;
+      expect(result).toEqual(expected);
+    });
+
+    test(`Unnested ::text[] input parameters (${mode})`, async () => {
+      const queryStringSQL = `/* @name getNullStringUnnestedValues */
+SELECT * FROM UNNEST(:nullStringUnnestedValues!::text[]);`;
+      const queryStringTS = `const getNullStringUnnestedValues = sql\`SELECT * FROM UNNEST($nullStringUnnestedValues::text[])\``;
+
+      const queryString =
+        mode === ProcessingMode.SQL ? queryStringSQL : queryStringTS;
+
+      const mockTypes: IQueryTypes = {
+        returnTypes: [
+          {
+            columnName: 'unnest',
+            returnName: 'unnest',
+            type: 'text',
+          },
+        ],
+        paramMetadata: {
+          params: ['_text'],
+          mapping: [
+            {
+              name: 'nullStringUnnestedValues',
+              type: ParameterTransform.Scalar,
+              required: true,
+              assignedIndex: 1,
+            },
+          ],
+        },
+      };
+
+      const typeSource = async (_: any) => mockTypes;
+      const types = new TypeAllocator(TypeMapping());
+
+      // Test out imports
+      types.use(
+        { name: 'PreparedQuery', from: '@pgtyped/runtime' },
+        TypeScope.Return,
+      );
+
+      const result = await queryToTypeDeclarations(
+        parsedQuery(mode, queryString),
+        typeSource,
+        types,
+        { hungarianNotation: true } as ParsedConfig,
+      );
+
+      const expectedTypes = `import { PreparedQuery } from '@pgtyped/runtime';
+
+export type NullStringArray = (null | string)[];\n`;
+      expect(types.declaration('file.ts')).toEqual(expectedTypes);
+      const expected = `/** 'GetNullStringUnnestedValues' parameters type */
+export interface IGetNullStringUnnestedValuesParams {
+  nullStringUnnestedValues: NullStringArray;
+}
+
+/** 'GetNullStringUnnestedValues' return type */
+export interface IGetNullStringUnnestedValuesResult {
+  unnest: string | null;
+}
+
+/** 'GetNullStringUnnestedValues' query type */
+export interface IGetNullStringUnnestedValuesQuery {
+  params: IGetNullStringUnnestedValuesParams;
+  result: IGetNullStringUnnestedValuesResult;
 }\n\n`;
       expect(result).toEqual(expected);
     });

packages/cli/src/types.test.ts

@@ -20,7 +20,7 @@ describe('TypeAllocator', () => {
     // expect both to be included
     expect(types.types).toMatchObject({
       Json: expect.objectContaining({ name: 'Json' }),
-      JsonArray: expect.objectContaining({ name: 'JsonArray' }),
+      NullJsonArray: expect.objectContaining({ name: 'NullJsonArray' }),
     });
   });
 });

packages/cli/src/types.ts

@@ -31,9 +31,12 @@ const Json: Type = {
   definition:
     'null | boolean | number | string | Json[] | { [key: string]: Json }',
 };
+
+const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+
 const getArray = (baseType: Type): Type => ({
-  name: `${baseType.name}Array`,
-  definition: `(${baseType.definition ?? baseType.name})[]`,
+  name: `Null${capitalize(baseType.name)}Array`,
+  definition: `(null | ${baseType.definition ?? baseType.name})[]`,
 });
 
 export const DefaultTypeMapping = Object.freeze({