Added strongly typed entries for better type checking

Author: oskardudycz

src/packages/pongo/src/main/client.ts

@@ -1,5 +1,5 @@
 import { getDbClient } from './dbClient';
-import type { PongoClient, PongoDb } from './typing';
+import type { PongoClient, PongoDb } from './typing/operations';
 
 export const pongoClient = (connectionString: string): PongoClient => {
   const dbClient = getDbClient(connectionString);

src/packages/pongo/src/main/dbClient.ts

@@ -1,5 +1,5 @@
 import { postgresClient } from '../postgres';
-import type { PongoCollection } from './typing';
+import type { PongoCollection } from './typing/operations';
 
 export interface DbClient {
   connect(): Promise<void>;

src/packages/pongo/src/main/index.ts

@@ -1,3 +1,3 @@
 export * from './client';
 export * from './dbClient';
-export * from './typing';
+export * from './typing/operations';

src/packages/pongo/src/main/typing/entries.ts

@@ -0,0 +1,12 @@
+type Entry<T> = {
+  [K in keyof Required<T>]: [K, Required<T>[K]];
+}[keyof Required<T>];
+
+type IterableEntry<T> = Entry<T> & {
+  [Symbol.iterator](): Iterator<Entry<T>>;
+};
+
+export const entries = <T extends object>(obj: T): IterableEntry<T>[] =>
+  Object.entries(obj).map(([key, value]) => [key as keyof T, value]);
+
+export type NonPartial<T> = { [K in keyof Required<T>]: T[K] };

src/packages/pongo/src/main/typing/index.ts

@@ -0,0 +1,2 @@
+export * from './entries';
+export * from './operations';

src/packages/pongo/src/main/typing.ts src/packages/pongo/src/main/typing/operations.ts

@@ -1,4 +1,5 @@
 import type { PongoFilter } from '../../main';
+import { entries } from '../../main/typing';
 import { Operators, handleOperator, hasOperators } from './queryOperators';
 
 const AND = 'AND';
@@ -18,7 +19,7 @@ const constructComplexFilterQuery = (
 ): string => {
   const isEquality = !hasOperators(value);
 
-  return Object.entries(value)
+  return entries(value)
     .map(
       ([nestedKey, val]) =>
         isEquality

src/packages/pongo/src/postgres/filter/index.ts

@@ -1,4 +1,5 @@
 import format from 'pg-format';
+import { entries } from '../../main/typing';
 
 export const Operators = {
   $eq: '$eq',
@@ -67,7 +68,7 @@ export const handleOperator = (
         (value as unknown[]).map((v) => format('%L', v)).join(', '),
       );
     case '$elemMatch': {
-      const subQuery = Object.entries(value as Record<string, unknown>)
+      const subQuery = entries(value as Record<string, unknown>)
         .map(([subKey, subValue]) =>
           format(`@."%s" == %s`, subKey, JSON.stringify(subValue)),
         )

src/packages/pongo/src/postgres/filter/queryOperators.ts

@@ -1,7 +1,24 @@
 import type { $inc, $push, $set, $unset, PongoUpdate } from '../../main';
+import { entries } from '../../main/typing';
 import { sql, type SQL } from '../sql';
 
-export const buildUpdateQuery = <T>(update: PongoUpdate<T>): SQL => {
+export const buildUpdateQuery = <T>(update: PongoUpdate<T>): SQL =>
+  entries(update).reduce((currentUpdateQuery, [op, value]) => {
+    switch (op) {
+      case '$set':
+        return buildSetQuery(value, currentUpdateQuery);
+      case '$unset':
+        return buildUnsetQuery(value, currentUpdateQuery);
+      case '$inc':
+        return buildIncQuery(value, currentUpdateQuery);
+      case '$push':
+        return buildPushQuery(value, currentUpdateQuery);
+      default:
+        return currentUpdateQuery;
+    }
+  }, sql('data'));
+
+export const buildUpdateQueryOld = <T>(update: PongoUpdate<T>): SQL => {
   let updateQuery = sql('data');
 
   if ('$set' in update && update.$set)

src/packages/pongo/src/postgres/update/index.ts

@@ -39,6 +39,7 @@
     // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
 
     /* Additional Checks */
+    "exactOptionalPropertyTypes": true,
     "noUnusedLocals": false /* Report errors on unused locals. */,
     "noUnusedParameters": false /* Report errors on unused parameters. */,
     "noImplicitReturns": true /* Report error when not all code paths in function return a value. */,