[feature request] insert/update params type nullability

currently, input types for insert and update queries (the ones in SET column_name = :param) are always defined as param: Type | null | void.

ideally, pgtyped should infer nullability. but you said in #118 that can’t be done easily.

you could implement a new syntax for explicitly specifying nullability and generate nullable types accordingly, e.g:

• :param -> current behaviour (no breaking changes), emit warning if ambiguous (possibly behind a flag)
• :?param or :param? -> force nullable type
• :!param or :param! -> force non nullable type

also, when you generate properties as name: Type | null | void, parameters are required by TS (have to explicitly set the to undefined), it would be better to generate them as name?: Type | null (undefined is still accepted by TS, but you can also omit that property).

[JohnnyCrazy]

I was quite intrigued by the idea and think this would be a great expansion for pgtyped. Since I wanted to dive into pgtyped anyway, I went ahead and created a small prototype (https://github.com/JohnnyCrazy/pgtyped/tree/param-nullability) with the following syntax:

Scalar

/* @name GetAllComments */
SELECT * FROM book_comments WHERE id = :id! OR user_id = :id;

Since :id is required at least once, it will not be nullable:

export interface IGetAllCommentsParams {
  id: number;
}

Array

/*
  @name GetAllCommentsByIds
  @param ids -> (...)
*/
SELECT * FROM book_comments WHERE id in :ids!;

We can also handle array spread syntax in the query itself

export interface IGetAllCommentsByIdsParams {
  ids: readonly (number)[];
}

Pick

/*
  @name InsertSingleComment
  @param comment -> (userId!, commentBody)
*/
INSERT INTO book_comments (user_id, body) VALUES :comment;

In the pick syntax we have to declare required keys in the param declaration, since the object itself is required anyway

export interface IInsertSingleCommentParams {
  comment: {
    userId: number,
    commentBody: string | null | void
  };
}

Array Pick

/*
  @name InsertBooks
  @param books -> ((rank!, name!, authorId)...)
*/
INSERT INTO books (rank, name, author_id)
VALUES :books RETURNING id as book_id;

In the pick syntax we have to declare required keys in the param declaration, since the array itself is required anyway

export interface IInsertBooksParams {
  books: readonly ({
    rank: number,
    name: string,
    authorId: number | null | void
  })[];
}

The TS version is pretty much the same principle, $userId! $$users! $user(id!, body). I didn’t find any mayor deal breakers and it should be non-breaking (I don’t think ! behind a variable is any valid postgres query). So in the end depends on @adelsz if he would like to see this in the project, I could clean up the branch and PR it.

[adelsz]

Thanks @JohnnyCrazy, that is a great proposal. I like the suffix modificator approach and will be happy to review & merge if you are willing to put together a draft PR.