prostgles-server 4.2.265 → 4.2.266

package/lib/JSONBValidation/JSONBValidation.ts

@@ -1,4 +1,4 @@
-import { getKeys, getObjectEntries, isObject, JSONB } from "prostgles-types";
+import { getKeys, getObjectEntries, isEmpty, isObject, JSONB } from "prostgles-types";
 
 export const getFieldTypeObj = (rawFieldType: JSONB.FieldType): JSONB.FieldTypeObj => {
   if (typeof rawFieldType === "string") return { type: rawFieldType };
@@ -51,36 +51,35 @@ const getValidator = (type: Extract<DataType, string>) => {
 };
 
 const getPropertyValidationError = (
-  key: string,
-  val: any,
+  value: any,
   rawFieldType: JSONB.FieldType,
   path: string[] = []
 ): string | undefined => {
-  let err = `${[...path, key].join(".")} is of invalid type. Expecting `;
+  const err = `${path.join(".")} is of invalid type. Expecting ${getTypeDescription(rawFieldType).replaceAll("\n", "")}`;
   const fieldType = getFieldTypeObj(rawFieldType);
+
   const { type, allowedValues, nullable, optional } = fieldType;
-  if (nullable && val === null) return;
-  if (optional && val === undefined) return;
+  if (nullable && value === null) return;
+  if (optional && value === undefined) return;
   if (allowedValues) {
     throw new Error(`Allowed values are not supported for validation`);
   }
   if (type) {
     if (isObject(type)) {
-      if (!isObject(val)) {
-        return `${[...path, key].join(".")} is of invalid type. Expecting object`;
+      if (!isObject(value)) {
+        return err;
       }
       for (const [subKey, subSchema] of getObjectEntries(type)) {
-        const error = getPropertyValidationError(subKey, val[subKey], subSchema, [...path, key]);
-        if (error) {
+        const error = getPropertyValidationError(value[subKey], subSchema, [...path, subKey]);
+        if (error !== undefined) {
           return error;
         }
       }
       return;
     }
-    err += type;
 
     const { validator } = getValidator(type);
-    const isValid = validator(val);
+    const isValid = validator(value);
     if (!isValid) {
       return err;
     }
@@ -91,14 +90,102 @@ const getPropertyValidationError = (
     const otherOptions = [];
     if (fieldType.nullable) otherOptions.push(null);
     if (fieldType.optional) otherOptions.push(undefined);
-    err += `one of: ${JSON.stringify([...fieldType.enum, ...otherOptions]).slice(1, -1)}`;
+    // err += `one of: ${JSON.stringify([...fieldType.enum, ...otherOptions]).slice(1, -1)}`;
 
-    if (!fieldType.enum.includes(val)) return err;
+    if (!fieldType.enum.includes(value)) return err;
+    return;
+  }
+  if (fieldType.oneOf) {
+    if (!fieldType.oneOf.length) {
+      return err + "to not be empty";
+    }
+    let firstError: string | undefined;
+    const validMember = fieldType.oneOf.find((member) => {
+      const error = getPropertyValidationError(value, member, path);
+      firstError ??= error;
+      return error === undefined;
+    });
+    if (validMember) {
+      return;
+    }
+    return err;
+  }
+  if (fieldType.record) {
+    const { keysEnum, partial, values: valuesSchema } = fieldType.record;
+    if (!isObject(value)) {
+      return err + "object";
+    }
+    if (partial && isEmpty(value)) {
+      return;
+    }
+    const valueKeys = getKeys(value);
+    const missingKey = partial ? undefined : keysEnum?.find((key) => !valueKeys.includes(key));
+    if (missingKey !== undefined) {
+      return `${err} to have key ${missingKey}`;
+    }
+    const extraKeys = valueKeys.filter((key) => !keysEnum?.includes(key));
+    if (extraKeys.length) {
+      return `${err} has extra keys: ${extraKeys}`;
+    }
+    if (valuesSchema) {
+      for (const [propKey, propValue] of Object.entries(value)) {
+        const valError = getPropertyValidationError(propValue, valuesSchema, [...path, propKey]);
+        if (valError !== undefined) {
+          return `${valError}`;
+        }
+      }
+    }
     return;
   }
   return `Could not validate field type: ${JSON.stringify(fieldType)}`;
 };
 
+const getTypeDescription = (schema: JSONB.FieldType): string => {
+  const schemaObj = getFieldTypeObj(schema);
+  const { type, nullable, optional, oneOf, record } = schemaObj;
+  const allowedTypes: any[] = [];
+  if (nullable) allowedTypes.push("null");
+  if (optional) allowedTypes.push("undefined");
+  if (typeof type === "string") {
+    allowedTypes.push(type);
+  } else if (type) {
+    if (isObject(type)) {
+      const keyOpts: string[] = [];
+      Object.entries(type).forEach(([key, value]) => {
+        keyOpts.push(`${key}: ${getTypeDescription(value)}`);
+      });
+      allowedTypes.push(`{ ${keyOpts.join("; ")} }`);
+    }
+  }
+  schemaObj.enum?.forEach((v) => {
+    if (v === null) {
+      allowedTypes.push("null");
+    } else if (v === undefined) {
+      allowedTypes.push("undefined");
+    } else if (typeof v === "string") {
+      allowedTypes.push(JSON.stringify(v));
+    } else {
+      allowedTypes.push(v);
+    }
+  });
+  oneOf?.forEach((v) => {
+    const type = getTypeDescription(v);
+    allowedTypes.push(type);
+  });
+  if (record) {
+    const { keysEnum, partial, values } = record;
+    const optional = partial ? "?" : "";
+    const valueType = !values ? "any" : getTypeDescription(values);
+    if (keysEnum) {
+      allowedTypes.push(`{ [${keysEnum.join(" | ")}]${optional}: ${valueType} }`);
+    } else {
+      allowedTypes.push(`{ [key: string]${optional}: ${valueType} }`);
+    }
+  }
+
+  return allowedTypes.join(" | ");
+};
+
 export const getJSONBObjectSchemaValidationError = <S extends JSONB.ObjectType["type"]>(
   schema: S,
   obj: any,
@@ -110,7 +197,7 @@ export const getJSONBObjectSchemaValidationError = <S extends JSONB.ObjectType["
     return { error: `Expecting ${objName} to be an object` };
   }
   for (const [k, objSchema] of Object.entries(schema)) {
-    const error = getPropertyValidationError(k, obj[k], objSchema);
+    const error = getPropertyValidationError(obj[k], objSchema, [k]);
     if (error) {
       return { error };
     }

package/lib/JSONBValidation/getJSONBSchemaTSTypes.ts

@@ -11,124 +11,124 @@ export function getJSONBSchemaTSTypes(
   outerLeading = "",
   tables: TableSchema[]
 ): string {
-  const getFieldType = (
-    rawFieldType: JSONB.FieldType,
-    isOneOf = false,
-    innerLeading = "",
-    depth = 0
-  ): string => {
-    const fieldType = getFieldTypeObj(rawFieldType);
-    const nullType = fieldType.nullable ? `null | ` : "";
+  return getJSONBTSTypes(
+    tables,
+    { ...(schema as JSONB.FieldTypeObj), nullable: colOpts.nullable },
+    undefined,
+    outerLeading
+  );
+}
 
-    /** Primitives */
-    if (typeof fieldType.type === "string") {
-      const correctType = fieldType.type
-        .replace("integer", "number")
-        .replace("time", "string")
-        .replace("timestamp", "string")
-        .replace("Date", "string");
+export const getJSONBTSTypes = (
+  tables: TableSchema[],
+  rawFieldType: JSONB.FieldType,
+  isOneOf = false,
+  innerLeading = "",
+  depth = 0
+): string => {
+  const fieldType = getFieldTypeObj(rawFieldType);
+  const nullType = fieldType.nullable ? `null | ` : "";
 
-      if (fieldType.allowedValues && fieldType.type.endsWith("[]")) {
-        return (
-          nullType + ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`
-        );
-      }
-      return nullType + correctType;
+  /** Primitives */
+  if (typeof fieldType.type === "string") {
+    const correctType = fieldType.type
+      .replace("integer", "number")
+      .replace("time", "string")
+      .replace("timestamp", "string")
+      .replace("Date", "string");
 
-      /** Object */
-    } else if (isObject(fieldType.type)) {
-      const addSemicolonIfMissing = (v: string) => (v.trim().endsWith(";") ? v : v.trim() + ";");
-      const { type } = fieldType;
-      const spacing = isOneOf ? " " : "  ";
-      let objDef =
-        ` {${spacing}` +
-        getKeys(type)
-          .map((key) => {
-            const fieldType = getFieldTypeObj(type[key]!);
-            const escapedKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-            return (
-              `${spacing}${escapedKey}${fieldType.optional ? "?" : ""}: ` +
-              addSemicolonIfMissing(getFieldType(fieldType, true, undefined, depth + 1))
-            );
-          })
-          .join(" ") +
-        `${spacing}}`;
-      if (!isOneOf) {
-        objDef = addSemicolonIfMissing(objDef);
-      }
+    if (fieldType.allowedValues && fieldType.type.endsWith("[]")) {
+      return nullType + ` (${fieldType.allowedValues.map((v) => JSON.stringify(v)).join(" | ")})[]`;
+    }
+    return nullType + correctType;
 
-      /** Keep single line */
-      if (isOneOf) {
-        objDef = objDef.split("\n").join("");
-      }
-      return nullType + objDef;
-    } else if (fieldType.enum) {
-      return nullType + fieldType.enum.map((v) => asValue(v)).join(" | ");
-    } else if (fieldType.oneOf || fieldType.oneOfType) {
-      const oneOf = fieldType.oneOf || fieldType.oneOfType.map((type) => ({ type }));
-      return (
-        (fieldType.nullable ? `\n${innerLeading} | null` : "") +
-        oneOf
-          .map((v) => `\n${innerLeading} | ` + getFieldType(v, true, undefined, depth + 1))
-          .join("")
-      );
-    } else if (fieldType.arrayOf || fieldType.arrayOfType) {
-      const arrayOf = fieldType.arrayOf || { type: fieldType.arrayOfType };
-      return `${fieldType.nullable ? `null | ` : ""} ( ${getFieldType(arrayOf, true, undefined, depth + 1)} )[]`;
-    } else if (fieldType.record) {
-      const { keysEnum, values, partial } = fieldType.record;
-      // TODO: ensure props with undefined values are not allowed in the TS type (strict union)
-      const getRecord = (v: string) => (partial ? `Partial<Record<${v}>>` : `Record<${v}>`);
-      return `${fieldType.nullable ? `null |` : ""} ${getRecord(`${keysEnum?.map((v) => asValue(v)).join(" | ") ?? "string"}, ${!values ? "any" : getFieldType(values, true, undefined, depth + 1)}`)}`;
-    } else if (fieldType.lookup) {
-      const l = fieldType.lookup;
-      if (l.type === "data-def") {
-        return `${fieldType.nullable ? `null |` : ""} ${getFieldType({
-          type: {
-            table: "string",
-            column: "string",
-            filter: { record: {}, optional: true },
-            isArray: { type: "boolean", optional: true },
-            searchColumns: { type: "string[]", optional: true },
-            isFullRow: {
-              optional: true,
-              type: {
-                displayColumns: { type: "string[]", optional: true },
-              },
+    /** Object */
+  } else if (isObject(fieldType.type)) {
+    const addSemicolonIfMissing = (v: string) => (v.trim().endsWith(";") ? v : v.trim() + ";");
+    const { type } = fieldType;
+    const spacing = isOneOf ? " " : "  ";
+    let objDef =
+      ` {${spacing}` +
+      getKeys(type)
+        .map((key) => {
+          const fieldType = getFieldTypeObj(type[key]!);
+          const escapedKey = isValidIdentifier(key) ? key : JSON.stringify(key);
+          return (
+            `${spacing}${escapedKey}${fieldType.optional ? "?" : ""}: ` +
+            addSemicolonIfMissing(getJSONBTSTypes(tables, fieldType, true, undefined, depth + 1))
+          );
+        })
+        .join(" ") +
+      `${spacing}}`;
+    if (!isOneOf) {
+      objDef = addSemicolonIfMissing(objDef);
+    }
+
+    /** Keep single line */
+    if (isOneOf) {
+      objDef = objDef.split("\n").join("");
+    }
+    return nullType + objDef;
+  } else if (fieldType.enum) {
+    return nullType + fieldType.enum.map((v) => asValue(v)).join(" | ");
+  } else if (fieldType.oneOf || fieldType.oneOfType) {
+    const oneOf = fieldType.oneOf || fieldType.oneOfType.map((type) => ({ type }));
+    return (
+      (fieldType.nullable ? `\n${innerLeading} | null` : "") +
+      oneOf
+        .map((v) => `\n${innerLeading} | ` + getJSONBTSTypes(tables, v, true, undefined, depth + 1))
+        .join("")
+    );
+  } else if (fieldType.arrayOf || fieldType.arrayOfType) {
+    const arrayOf = fieldType.arrayOf || { type: fieldType.arrayOfType };
+    return `${fieldType.nullable ? `null | ` : ""} ( ${getJSONBTSTypes(tables, arrayOf, true, undefined, depth + 1)} )[]`;
+  } else if (fieldType.record) {
+    const { keysEnum, values, partial } = fieldType.record;
+    // TODO: ensure props with undefined values are not allowed in the TS type (strict union)
+    const getRecord = (v: string) => (partial ? `Partial<Record<${v}>>` : `Record<${v}>`);
+    return `${fieldType.nullable ? `null |` : ""} ${getRecord(`${keysEnum?.map((v) => asValue(v)).join(" | ") ?? "string"}, ${!values ? "any" : getJSONBTSTypes(tables, values, true, undefined, depth + 1)}`)}`;
+  } else if (fieldType.lookup) {
+    const l = fieldType.lookup;
+    if (l.type === "data-def") {
+      return `${fieldType.nullable ? `null |` : ""} ${getJSONBTSTypes(tables, {
+        type: {
+          table: "string",
+          column: "string",
+          filter: { record: {}, optional: true },
+          isArray: { type: "boolean", optional: true },
+          searchColumns: { type: "string[]", optional: true },
+          isFullRow: {
+            optional: true,
+            type: {
+              displayColumns: { type: "string[]", optional: true },
             },
-            showInRowCard: { optional: true, record: {} },
           },
-        })}`;
-      }
+          showInRowCard: { optional: true, record: {} },
+        },
+      })}`;
+    }
 
-      const isSChema = l.type === "schema";
-      let type =
-        isSChema ?
-          l.object === "table" ?
-            "string"
-          : `{ "table": string; "column": string; }`
-        : "";
-      if (!isSChema) {
-        const cols = tables.find((t) => t.name === l.table)?.columns;
-        if (!l.isFullRow) {
-          type = postgresToTsType(cols?.find((c) => c.name === l.column)?.udt_name ?? "text");
-        } else {
-          type =
-            !cols ? "any" : (
-              `{ ${cols.map((c) => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${postgresToTsType(c.udt_name)}; `).join(" ")} }`
-            );
-        }
+    const isSChema = l.type === "schema";
+    let type =
+      isSChema ?
+        l.object === "table" ?
+          "string"
+        : `{ "table": string; "column": string; }`
+      : "";
+    if (!isSChema) {
+      const cols = tables.find((t) => t.name === l.table)?.columns;
+      if (!l.isFullRow) {
+        type = postgresToTsType(cols?.find((c) => c.name === l.column)?.udt_name ?? "text");
+      } else {
+        type =
+          !cols ? "any" : (
+            `{ ${cols.map((c) => `${JSON.stringify(c.name)}: ${c.is_nullable ? "null | " : ""} ${postgresToTsType(c.udt_name)}; `).join(" ")} }`
+          );
       }
-      return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray ? "[]" : ""}`;
-    } else throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType, schema }, null, 2);
-  };
-
-  return getFieldType(
-    { ...(schema as JSONB.FieldTypeObj), nullable: colOpts.nullable },
-    undefined,
-    outerLeading
-  );
-}
+    }
+    return `${fieldType.nullable ? `null | ` : ""}${type}${l.isArray ? "[]" : ""}`;
+  } else throw "Unexpected getSchemaTSTypes: " + JSON.stringify({ fieldType }, null, 2);
+};
 
 const isValidIdentifier = (str: string) => {
   const identifierRegex = /^[A-Za-z$_][A-Za-z0-9$_]*$/;

package/lib/PubSubManager/PubSubManager.ts

@@ -29,6 +29,7 @@ import {
   SelectParams,
   SubscribeParams,
   WAL,
+  type SubscribeOptions,
 } from "prostgles-types";
 
 import { find, pickKeys } from "prostgles-types/dist/util";
@@ -109,7 +110,7 @@ export type ViewSubscriptionOptions = (
   }[];
 };
 
-export type SubscriptionParams = Pick<SubscribeParams, "throttle" | "throttleOpts"> & {
+export type SubscriptionParams = {
   socket_id?: string;
   channel_name: string;
 
@@ -124,22 +125,23 @@ export type SubscriptionParams = Pick<SubscribeParams, "throttle" | "throttleOpt
   /* Used as input */
   table_rules?: ParsedTableRule;
   filter: object;
-  params: SelectParams;
+  selectParams: SelectParams;
+  subscribeOptions: SubscribeOptions;
 
   localFuncs?: LocalFuncs;
   socket: PRGLIOSocket | undefined;
 
-  last_throttled: number;
+  lastPushed: number;
   is_throttling?: any;
   is_ready?: boolean;
 };
 
 export type Subscription = Pick<
   SubscriptionParams,
-  | "throttle"
+  | "selectParams"
+  | "subscribeOptions"
   | "is_throttling"
-  | "last_throttled"
-  | "throttleOpts"
+  | "lastPushed"
   | "channel_name"
   | "is_ready"
   | "localFuncs"
@@ -147,7 +149,6 @@ export type Subscription = Pick<
   | "socket_id"
   | "table_info"
   | "filter"
-  | "params"
   | "table_rules"
 > & {
   triggers: {
@@ -298,7 +299,7 @@ export class PubSubManager {
   getSubData = async (
     sub: Subscription
   ): Promise<{ data: any[]; err?: undefined } | { data?: undefined; err: any }> => {
-    const { table_info, filter, params, table_rules } = sub; //, subOne = false
+    const { table_info, filter, selectParams: params, table_rules } = sub; //, subOne = false
     const { name: table_name } = table_info;
 
     if (!this.dbo[table_name]?.find) {

package/lib/PubSubManager/addSub.ts

@@ -1,4 +1,6 @@
 import { SubscriptionChannels } from "prostgles-types";
+import { VoidFunction } from "../SchemaWatch/SchemaWatch";
+import { tout } from "./initPubSubManager";
 import {
   BasicCallback,
   parseCondition,
@@ -6,7 +8,6 @@ import {
   Subscription,
   SubscriptionParams,
 } from "./PubSubManager";
-import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 
 type AddSubscriptionParams = SubscriptionParams & {
   condition: string;
@@ -27,12 +28,11 @@ export async function addSub(
     localFuncs,
     table_rules,
     filter = {},
-    params = {},
+    selectParams = {},
     condition = "",
-    throttle = 0, //subOne = false,
     viewOptions,
     table_info,
-    throttleOpts,
+    subscribeOptions,
   } = subscriptionParams;
   const table_name = table_info.name;
 
@@ -43,16 +43,7 @@ export async function addSub(
     throw "addSub: cannot have socket AND func";
   }
 
-  let validated_throttle = subscriptionParams.throttle || 10;
-  const pubThrottle = table_rules?.subscribe?.throttle || 0;
-  if (pubThrottle && Number.isInteger(pubThrottle) && pubThrottle > 0) {
-    validated_throttle = pubThrottle;
-  }
-  if (throttle && Number.isInteger(throttle) && throttle >= pubThrottle) {
-    validated_throttle = throttle;
-  }
-
-  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(params)}.${"m"}.sub`;
+  const channel_name = `${this.socketChannelPreffix}.${table_name}.${JSON.stringify(filter)}.${JSON.stringify(selectParams)}.${"m"}.sub`;
   const mainTrigger = {
     table_name: table_name,
     condition: parseCondition(condition),
@@ -63,16 +54,16 @@ export async function addSub(
     channel_name,
     filter,
     localFuncs,
-    params,
-    last_throttled: 0,
+    selectParams: selectParams,
+    lastPushed: 0,
     socket,
-    throttleOpts,
+    subscribeOptions,
     table_info,
     is_ready: true,
     is_throttling: false,
     socket_id: socket?.id,
     table_rules,
-    throttle: validated_throttle,
+
     triggers: [mainTrigger],
   };
 
@@ -105,14 +96,21 @@ export async function addSub(
     }
   }
 
+  const { skipFirst, throttleOpts, throttle } = subscribeOptions;
+  const sendFirstData = async () => {
+    if (skipFirst) return;
+    if (throttleOpts?.skipFirst && throttle) {
+      await tout(throttle);
+    }
+    void this.pushSubData(newSub);
+  };
+
   if (localFuncs) {
     /**
      * Must ensure sub will start sending data after all triggers are set up.
      * Socket clients are not affected as they need to confirm they are ready to receive data
      */
-    result.sendFirstData = () => {
-      void this.pushSubData(newSub);
-    };
+    result.sendFirstData = sendFirstData;
   } else if (socket) {
     const removeListeners = () => {
       socket.removeAllListeners(channel_name);
@@ -121,9 +119,7 @@ export async function addSub(
     };
     removeListeners();
 
-    socket.once(result.channelNameReady, () => {
-      void this.pushSubData(newSub);
-    });
+    socket.once(result.channelNameReady, sendFirstData);
     socket.once(result.channelNameUnsubscribe, (_data: any, cb: BasicCallback) => {
       const res = "ok";
       this.subs = this.subs.filter((s) => {

package/lib/PubSubManager/notifListener.ts

@@ -1,3 +1,4 @@
+import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import { log, NOTIF_TYPE, NotifTypeName, pickKeys, PubSubManager } from "./PubSubManager";
 
 /* Relay relevant data to relevant subscriptions */
@@ -128,10 +129,22 @@ export async function notifListener(this: PubSubManager, data: { payload: string
         )
       );
       activeAndReadySubs.forEach((sub) => {
-        const { throttle = 0, throttleOpts } = sub;
-        if (!throttleOpts?.skipFirst && sub.last_throttled <= Date.now() - throttle) {
-          sub.last_throttled = Date.now();
+        const { throttle = 0, throttleOpts, actions } = sub.subscribeOptions;
+
+        const commandLowerCase = (op_name?.toLowerCase() || "insert") as keyof NonNullable<
+          typeof actions
+        >;
+
+        const actionIsIgnored =
+          actions &&
+          !parseFieldFilter(actions, false, ["insert", "update", "delete"]).includes(
+            commandLowerCase as any
+          );
+        if (actionIsIgnored) {
+          return;
+        }
 
+        if (!throttleOpts?.skipFirst && sub.lastPushed <= Date.now() - throttle) {
           /* It is assumed the policy was checked before this point */
           void this.pushSubData(sub);
         } else if (!sub.is_throttling) {
@@ -139,7 +152,6 @@ export async function notifListener(this: PubSubManager, data: { payload: string
           sub.is_throttling = setTimeout(() => {
             log("throttling finished. pushSubData...");
             sub.is_throttling = null;
-            sub.last_throttled = Date.now();
             void this.pushSubData(sub);
           }, throttle);
         }

package/lib/PubSubManager/pushSubData.ts

@@ -35,6 +35,7 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
     return true;
   }
 
+  sub.lastPushed = Date.now();
   return new Promise(async (resolve, reject) => {
     /* TODO: Retire subOne -> it's redundant */
 
@@ -57,7 +58,6 @@ export async function pushSubData(this: PubSubManager, sub: Subscription, err?:
       } else {
         onLog("no client to push data to");
       }
-      // sub.last_throttled = Date.now();
     } else {
       onLog("fetch data error");
       const errObj = { _err_msg: err.toString(), err };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.265",
+  "version": "4.2.266",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -57,7 +57,7 @@
     "pg": "^8.11.5",
     "pg-cursor": "^2.11.0",
     "pg-promise": "^11.9.1",
-    "prostgles-types": "^4.0.161"
+    "prostgles-types": "^4.0.164"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",