prostgles-server 4.2.448 → 4.2.449

package/lib/DboBuilder/QueryBuilder/getSelectQuery.ts

@@ -18,7 +18,7 @@ export function getSelectQuery(
   viewHandler: ViewHandler,
   q: NewQuery,
   depth = 0,
-  selectParamsGroupBy: boolean
+  selectParamsGroupBy: boolean,
 ): string {
   const rootSelect = q.select
     .filter((s) => s.selected)
@@ -27,7 +27,7 @@ export function getSelectQuery(
   const parsedJoins =
     q.joins?.flatMap((q2) => {
       const parsed = getJoinQuery(viewHandler, {
-        q1: { ...q, tableAlias: ROOT_TABLE_ALIAS },
+        q1: { ...q, tableAlias: { raw: ROOT_TABLE_ALIAS, escaped: ROOT_TABLE_ALIAS } },
         q2: { ...q2 },
         selectParamsGroupBy,
       });
@@ -40,8 +40,8 @@ export function getSelectQuery(
   const selectItems = rootSelect.concat(
     parsedJoins.map((join) => {
       const { joinAlias } = join;
-      return `COALESCE(${asName(joinAlias)}.${join.resultAlias}, '[]') as ${asName(joinAlias)}`;
-    })
+      return `COALESCE(${joinAlias.escaped}.${join.resultAlias.escaped}, '[]') as ${joinAlias.escaped}`;
+    }),
   );
 
   /** OR joins cannot be easily aggregated to one-many with the root table. Must group by root table id */
@@ -62,9 +62,9 @@ export function getSelectQuery(
   if (hasOrJoins) {
     const pkey = viewHandler.columns.find((c) => c.is_pkey);
     joinCtes = [
-      `${q.table} AS (`,
+      `${q.table.escaped} AS (`,
       `  SELECT *, ${pkey ? asName(pkey.name) : "ROW_NUMBER() OVER()"} as ${ROOT_TABLE_ROW_NUM_ID}`,
-      `  FROM ${q.table}`,
+      `  FROM ${q.table.escaped}`,
       `)`,
       joinCtes.length ? "," : "",
       ...joinCtes,
@@ -81,7 +81,7 @@ export function getSelectQuery(
     ...indentLines(selectItems, { appendCommas: true }),
     `FROM ( `,
     `  SELECT *`,
-    `  FROM ${q.table}`,
+    `  FROM ${q.table.escaped}`,
     ...(q.where ? [`  ${q.where}`] : []),
     `) ${ROOT_TABLE_ALIAS}`,
     ...parsedJoins.flatMap((j) => j.joinLines),
@@ -104,7 +104,7 @@ type IndentLinesOpts = {
 };
 export const indentLines = (
   strArr: (string | undefined | null)[],
-  { numberOfSpaces = 2, indentStr = " ", appendCommas = false }: IndentLinesOpts = {}
+  { numberOfSpaces = 2, indentStr = " ", appendCommas = false }: IndentLinesOpts = {},
 ): string[] => {
   const nonEmptyLines = strArr.filter((v) => v);
 
@@ -120,11 +120,10 @@ const indentLinesToString = (
   strArr: (string | undefined | null)[],
   numberOfSpaces = 0,
   separator = " \n ",
-  indentStr = " "
+  indentStr = " ",
 ) => indentLines(strArr, { numberOfSpaces, indentStr }).join(separator);
-const getTableAlias = (q: NewQuery) =>
-  !q.tableAlias ? q.table : `${q.tableAlias || ""}_${q.table}`;
-export const getTableAliasAsName = (q: NewQuery) => asName(getTableAlias(q));
+export const getTableAliasAsName = (q: NewQuery) =>
+  !q.tableAlias ? q.table.escaped : asName(`${q.tableAlias.raw || ""}_${q.table.raw}`);
 
 export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
   const aggs = q.select.filter((s) => s.selected && s.type === "aggregation");
@@ -133,11 +132,6 @@ export const getRootGroupBy = (q: NewQuery, selectParamsGroupBy?: boolean) => {
   if ((selectParamsGroupBy || aggs.length) && nonAggs.length) {
     /** Add ORDER BY items not included in root select */
     const orderByItems: string[] = [];
-    // q.orderByItems.forEach(sortItem => {
-    //   if (!sortItem.nested && "fieldQuery" in sortItem && !orderByItems.includes(sortItem.fieldQuery)) {
-    //     orderByItems.push(sortItem.fieldQuery);
-    //   }
-    // });
 
     return [
       `GROUP BY ${q.select

package/lib/DboBuilder/TableRules/getValidatedRules.ts

@@ -9,7 +9,7 @@ import { asNameAlias } from "../../utils/asNameAlias";
 export function getValidatedRules(
   this: ViewHandler,
   tableRules?: ParsedTableRule,
-  localParams?: LocalParams
+  localParams?: LocalParams,
 ): ValidatedTableRules {
   if (localParams?.clientReq?.socket && !tableRules) {
     throw "INTERNAL ERROR: Unexpected case -> localParams && !tableRules";
@@ -23,15 +23,15 @@ export function getValidatedRules(
         ({
           type: "column",
           name: fieldName,
-          getQuery: ({ tableAlias }) => asNameAlias(fieldName, tableAlias),
+          getQuery: ({ tableAliasRaw: tableAlias }) => asNameAlias(fieldName, tableAlias),
           selected: false,
-        }) as FieldSpec
+        }) as FieldSpec,
     )
     .concat(
       COMPUTED_FIELDS.map((c) => ({
         type: c.type,
         name: c.name,
-        getQuery: ({ tableAlias, allowedFields }) =>
+        getQuery: ({ tableAliasRaw: tableAlias, allowedFields }) =>
           c.getQuery({
             allowedFields,
             ctidField: undefined,
@@ -39,10 +39,10 @@ export function getValidatedRules(
 
             /* CTID not available in AFTER trigger */
             // ctidField: this.is_view? undefined : "ctid",
-            tableAlias,
+            tableAliasRaw: tableAlias,
           }),
         selected: false,
-      }))
+      })),
     );
 
   if (tableRules) {
@@ -50,7 +50,7 @@ export function getValidatedRules(
       throw "INTERNAL ERROR: Unexpected case -> Empty table rules for " + this.name;
     const throwFieldsErr = (
         command: "select" | "update" | "delete" | "insert",
-        fieldType = "fields"
+        fieldType = "fields",
       ) => {
         throw `Invalid publish.${this.name}.${command} rule -> ${fieldType} setting is missing.\nPlease specify allowed ${fieldType} in this format: "*" | { col_name: false } | { col1: true, col2: true }`;
       },
@@ -106,7 +106,7 @@ export function getValidatedRules(
         returningFields: parseFirstSpecifiedFieldFilter(
           tableRules.update.returningFields,
           tableRules.select?.fields,
-          tableRules.update.fields
+          tableRules.update.fields,
         ),
         filterFields: this.parseFieldFilter(tableRules.update.filterFields),
       };
@@ -121,7 +121,7 @@ export function getValidatedRules(
         returningFields: parseFirstSpecifiedFieldFilter(
           tableRules.insert.returningFields,
           tableRules.select?.fields,
-          tableRules.insert.fields
+          tableRules.insert.fields,
         ),
       };
     }

package/lib/DboBuilder/ViewHandler/parseComplexFilter.ts

@@ -16,7 +16,7 @@ const allowedComparators = FILTER_OPERANDS; //[">", "<", "=", "<=", ">=", "<>",
 type Args = {
   filter: AnyObject;
   complexFilterKey: string;
-  tableAlias: string | undefined;
+  tableAliasRaw: string | undefined;
   allowed_colnames: string[];
   columns: TableSchemaColumn[];
 };
@@ -33,7 +33,7 @@ type Args = {
 export const parseComplexFilter = ({
   filter,
   complexFilterKey,
-  tableAlias,
+  tableAliasRaw,
   allowed_colnames,
   columns,
 }: Args) => {
@@ -50,7 +50,7 @@ export const parseComplexFilter = ({
       if (!allowed_colnames.includes(column)) {
         throw `Dissallowed or Invalid column ${column}. Allowed columns: ${allowed_colnames}`;
       }
-      return asNameAlias(column, tableAlias);
+      return asNameAlias(column, tableAliasRaw);
     }
     const { funcName, args } = parseFunctionObject(funcData);
     const funcDef = parseFunction({
@@ -61,7 +61,7 @@ export const parseComplexFilter = ({
     });
     return funcDef.getQuery({
       args,
-      tableAlias,
+      tableAliasRaw,
       allColumns: columns,
       allowedFields: allowed_colnames,
     });

package/lib/DboBuilder/ViewHandler/prepareSortItems.ts

@@ -6,7 +6,7 @@ import {
   isEmpty,
   isObject,
 } from "prostgles-types/dist";
-import type { SortItem } from "../DboBuilder";
+import type { PGIdentifier, SortItem } from "../DboBuilder";
 import type { NewQueryJoin, SelectItemValidated } from "../QueryBuilder/QueryBuilder";
 import { asNameAlias } from "../../utils/asNameAlias";
 
@@ -14,9 +14,9 @@ import { asNameAlias } from "../../utils/asNameAlias";
 export const prepareSortItems = (
   rawOrderBy: OrderBy | undefined,
   allowed_cols: string[],
-  tableAlias: string | undefined,
+  tableAlias: PGIdentifier | undefined,
   select: SelectItemValidated[],
-  joinQueries: NewQueryJoin[]
+  joinQueries: NewQueryJoin[],
 ): SortItem[] => {
   if (!rawOrderBy) return [];
 
@@ -48,7 +48,7 @@ export const prepareSortItems = (
     .filter(
       (s) =>
         s.type !== "joinedColumn" &&
-        (!s.fields.length || s.fields.every((f) => allowed_cols.includes(f)))
+        (!s.fields.length || s.fields.every((f) => allowed_cols.includes(f))),
     )
     .map((s) => s.alias);
 
@@ -59,15 +59,15 @@ export const prepareSortItems = (
         ...jq,
         selectItem,
         joinAlias,
-        key: `${joinAlias}.${selectItem.alias}`,
+        key: `${joinAlias.raw}.${selectItem.alias}`,
       };
-    })
+    }),
   );
   const bad_param = orderBy.find(
     ({ key }) =>
       !sortableNestedColumns.some((v) => v.key === key) &&
       !validatedAggAliases.includes(key) &&
-      !allowed_cols.includes(key)
+      !allowed_cols.includes(key),
   );
   if (bad_param) {
     throw "Invalid/disallowed orderBy fields or params: " + bad_param.key;
@@ -95,9 +95,9 @@ export const prepareSortItems = (
           joinAlias,
           selectItemAlias: selectItem.alias,
           isNumeric: selectItem.tsDataType === "number",
-          wrapperQuerySortItem: `${asc ? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias)}${comparableDataTypeCast}) as ${sortItemAlias}`,
+          wrapperQuerySortItem: `${asc ? "MIN" : "MAX"}(${asNameAlias(selectItem.alias, joinAlias.raw)}${comparableDataTypeCast}) as ${sortItemAlias}`,
         },
-        fieldQuery: `${asName(joinAlias)}.${sortItemAlias + (asc ? "" : " DESC")} ${nulls ? `NULLS ${nulls === "last" ? "LAST" : "FIRST"}` : ""}`,
+        fieldQuery: `${joinAlias.escaped}.${sortItemAlias + (asc ? "" : " DESC")} ${nulls ? `NULLS ${nulls === "last" ? "LAST" : "FIRST"}` : ""}`,
       };
     }
     /* Order by column index when possible to bypass name collision when ordering by a computed column. 
@@ -106,7 +106,9 @@ export const prepareSortItems = (
 
     const index = selectedAliases.indexOf(key) + 1;
     let colKey =
-      index > 0 && !nullEmpty ? index : [tableAlias, key].filter(isDefined).map(asName).join(".");
+      index > 0 && !nullEmpty ?
+        index
+      : [tableAlias?.raw, key].filter(isDefined).map(asName).join(".");
     if (nullEmpty) {
       colKey = `nullif(trim(${colKey}::text), '')`;
     }
@@ -150,7 +152,7 @@ const throwErr = (rawOrderBy: any) => {
 
 const parseOrderObj = (
   orderBy: any,
-  expectOne = false
+  expectOne = false,
 ): {
   key: string;
   asc: boolean;
@@ -171,7 +173,7 @@ const parseOrderObj = (
         nullEmpty: { enum: [false, true, null], optional: true },
       } as const,
       orderBy,
-      "orderBy"
+      "orderBy",
     );
     if (data) {
       const { key, asc = true, nulls, nullEmpty = false } = data;

package/lib/DboBuilder/ViewHandler/prepareWhere.ts

@@ -1,7 +1,7 @@
-import type { AnyObject, FieldFilter} from "prostgles-types/dist";
+import type { AnyObject, FieldFilter } from "prostgles-types/dist";
 import { getKeys, isDefined, isObject } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
-import type { ExistsFilterConfig, Filter, LocalParams } from "../DboBuilder";
+import type { ExistsFilterConfig, Filter, LocalParams, PGIdentifier } from "../DboBuilder";
 import { getCondition } from "../getCondition";
 import { type SelectItemValidated } from "../QueryBuilder/QueryBuilder";
 import type { ViewHandler } from "./ViewHandler";
@@ -12,7 +12,7 @@ export type PrepareWhereParams = {
   forcedFilter?: AnyObject;
   filterFields?: FieldFilter;
   addWhere?: boolean;
-  tableAlias?: string;
+  tableAlias?: PGIdentifier;
   localParams: LocalParams | undefined;
   tableRule: ParsedTableRule | undefined;
   isHaving?: boolean;
@@ -20,7 +20,7 @@ export type PrepareWhereParams = {
 
 export async function prepareWhere(
   this: ViewHandler,
-  params: PrepareWhereParams
+  params: PrepareWhereParams,
 ): Promise<{
   condition: string;
   where: string;
@@ -48,7 +48,7 @@ export async function prepareWhere(
   const parseFullFilter = async (
     f: any,
     parentFilter: any = null,
-    isForcedFilterBypass: boolean
+    isForcedFilterBypass: boolean,
   ): Promise<string> => {
     if (!f) throw "Invalid/missing group filter provided";
     if (!isObject(f)) throw "\nInvalid filter\nExpecting an object but got -> " + JSON.stringify(f);
@@ -71,7 +71,7 @@ export async function prepareWhere(
       const operand = $and ? " AND " : " OR ";
       const conditions = (
         await Promise.all(
-          group.map(async (gf) => await parseFullFilter(gf, group, isForcedFilterBypass))
+          group.map(async (gf) => await parseFullFilter(gf, group, isForcedFilterBypass)),
         )
       ).filter((c) => c);
 

package/lib/DboBuilder/getCondition.ts

@@ -1,7 +1,7 @@
 import { asName, pickKeys } from "prostgles-types";
 import { parseFilterItem } from "../Filtering";
 import type { ParsedTableRule } from "../PublishParser/PublishParser";
-import type { ExistsFilterConfig, LocalParams } from "./DboBuilder";
+import type { ExistsFilterConfig, LocalParams, PGIdentifier } from "./DboBuilder";
 import { pgp } from "./DboBuilder";
 import { FUNCTIONS } from "./QueryBuilder/Functions/Functions";
 import { type SelectItemValidated } from "./QueryBuilder/QueryBuilder";
@@ -24,7 +24,7 @@ export async function getCondition(
     filter: any;
     select: SelectItemValidated[] | undefined;
     allowed_colnames: string[];
-    tableAlias?: string;
+    tableAlias?: PGIdentifier;
     localParams?: LocalParams;
     tableRules?: ParsedTableRule;
     isHaving?: boolean;
@@ -63,7 +63,7 @@ export async function getCondition(
         args: funcArgs,
         allColumns: this.columns,
         allowedFields: allowed_colnames,
-        tableAlias,
+        tableAliasRaw: tableAlias?.raw,
       }),
     );
   });
@@ -74,11 +74,7 @@ export async function getCondition(
       await Promise.all(
         existsConfigs.map(
           async (existsConfig) =>
-            await getExistsCondition.bind(this)(
-              existsConfig,
-              tableAlias && asName(tableAlias),
-              localParams,
-            ),
+            await getExistsCondition.bind(this)(existsConfig, tableAlias?.escaped, localParams),
         ),
       )
     ).join(" AND ");
@@ -94,7 +90,7 @@ export async function getCondition(
       if (!p.select) throw new Error("Computed column filter requires p.select.fields");
       computedColConditions.push(
         compCol.getQuery({
-          tableAlias,
+          tableAliasRaw: tableAlias?.raw,
           allowedFields: p.select.fields,
           allColumns: this.columns,
 
@@ -147,7 +143,7 @@ export async function getCondition(
           fields: [f.name],
           getQuery: (tableAlias) =>
             f.getQuery({
-              tableAlias,
+              tableAliasRaw: tableAlias,
               allColumns: this.columns,
               allowedFields: allowed_colnames,
             }),
@@ -163,7 +159,7 @@ export async function getCondition(
     const complexFilterCondition = parseComplexFilter({
       filter,
       complexFilterKey,
-      tableAlias,
+      tableAliasRaw: tableAlias?.raw,
       allowed_colnames,
       columns: this.columns,
     });
@@ -223,7 +219,7 @@ export async function getCondition(
   const f = pickKeys(filter, filterKeys);
   const q = parseFilterItem({
     filter: f,
-    tableAlias,
+    tableAliasRaw: tableAlias?.raw,
     select: allowedSelect,
     allowedColumnNames:
       !tableRules ?

package/lib/DboBuilder/getSubscribeRelatedTables.ts

@@ -76,7 +76,7 @@ export async function getSubscribeRelatedTables(
      * Avoid nested exists error. Will affect performance
      */
     for (const j of newQuery.joins ?? []) {
-      await pushRelatedTable(j.table, j.joinPath);
+      await pushRelatedTable(j.table.raw, j.joinPath);
     }
     for (const e of newQuery.whereOpts.exists.filter((e) => e.isJoined)) {
       for (const [index, pathItem] of e.parsedPath.entries()) {

package/lib/Filtering.ts

@@ -1,6 +1,4 @@
-import type {
-  FilterDataType,
-  FullFilter} from "prostgles-types";
+import type { FilterDataType, FullFilter } from "prostgles-types";
 import {
   BetweenFilterKeys,
   CompareFilterKeys,
@@ -47,7 +45,7 @@ export const FILTER_OPERAND_TO_SQL_OPERAND = Object.fromEntries(
     else if (filterOperand === "$isDistinctFrom") sqlOperand = "IS DISTINCT FROM";
     else if (filterOperand === "$isNotDistinctFrom") sqlOperand = "IS NOT DISTINCT FROM";
     return [filterOperand, sqlOperand];
-  })
+  }),
 ) as Record<(typeof FILTER_OPERANDS)[number], string>;
 
 /**
@@ -57,12 +55,12 @@ export const FILTER_OPERAND_TO_SQL_OPERAND = Object.fromEntries(
 type ParseFilterItemArgs = {
   filter: FullFilter<void, void> | undefined;
   select: SelectItemValidated[] | undefined;
-  tableAlias: string | undefined;
+  tableAliasRaw: string | undefined;
   allowedColumnNames: string[];
 };
 
 export const parseFilterItem = (args: ParseFilterItemArgs): string => {
-  const { filter: _f, select, tableAlias, allowedColumnNames } = args;
+  const { filter: _f, select, tableAliasRaw, allowedColumnNames } = args;
 
   if (!_f || isEmpty(_f)) return "";
 
@@ -84,9 +82,9 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
         parseFilterItem({
           filter: { [fk]: _f[fk] },
           select,
-          tableAlias,
+          tableAliasRaw,
           allowedColumnNames,
-        })
+        }),
       )
       .sort() /*  sorted to ensure duplicate subscription channels are not created due to different condition order */
       .join(" AND ");
@@ -106,7 +104,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
       const dissallowedFields = fields.filter((fname) => !allowedColumnNames.includes(fname));
       if (dissallowedFields.length) {
         throw new Error(
-          `Invalid/disallowed columns found in filter: ${dissallowedFields.join(", ")}`
+          `Invalid/disallowed columns found in filter: ${dissallowedFields.join(", ")}`,
         );
       }
     }
@@ -114,7 +112,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
   const getLeftQ = (selItm: SelectItemValidated) => {
     validateSelectedItemFilter(selItem);
     if (selItm.type === "function" || selItm.type === "aggregation") return selItm.getQuery();
-    return selItm.getQuery(tableAlias);
+    return selItm.getQuery(tableAliasRaw);
   };
 
   /**
@@ -131,14 +129,14 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
     /* See if dot notation. Pick the best matching starting string */
     if (select) {
       selItem = select.find((s) =>
-        dot_notation_delims.find((delimiter) => fKey.startsWith(s.alias + delimiter))
+        dot_notation_delims.find((delimiter) => fKey.startsWith(s.alias + delimiter)),
       );
       validateSelectedItemFilter(selItem);
     }
     if (!selItem) {
       return mErr(
         "Bad filter. Could not match to a column or alias or dot notation" +
-          select?.map((s) => s.alias).join(", ")
+          select?.map((s) => s.alias).join(", "),
       );
     }
 
@@ -148,7 +146,7 @@ export const parseFilterItem = (args: ParseFilterItemArgs): string => {
     if (remainingStr.startsWith("->")) {
       /** Has shorthand operand 'col->>key.<>'  */
       const matchingOperand = CompareFilterKeys.find((operand) =>
-        remainingStr.endsWith(`.${operand}`)
+        remainingStr.endsWith(`.${operand}`),
       );
       if (matchingOperand) {
         remainingStr = remainingStr.slice(0, -matchingOperand.length - 1);

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -144,7 +144,7 @@ export async function getSchemaFromPublish(
 
                       throw {
                         ...getErrorAsObject(e),
-                        publish_path: `publish.${tableName}.${method}: \n   -> ${e}`,
+                        publish_path: `publish.${tableName}.${method}`,
                       };
                     }
                   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.448",
+  "version": "4.2.449",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,16 +38,16 @@
   ],
   "homepage": "https://prostgles.com",
   "dependencies": {
-    "@aws-sdk/client-ses": "^3.985.0",
-    "@aws-sdk/credential-provider-node": "^3.972.4",
+    "@aws-sdk/client-ses": "^3.993.0",
+    "@aws-sdk/credential-provider-node": "^3.972.10",
     "@types/passport": "^1.0.17",
-    "@types/passport-facebook": "^3.0.3",
+    "@types/passport-facebook": "^3.0.4",
     "@types/passport-github2": "^1.2.9",
-    "@types/passport-google-oauth20": "^2.0.16",
+    "@types/passport-google-oauth20": "^2.0.17",
     "@types/passport-microsoft": "^1.0.3",
     "check-disk-space": "^3.4.0",
-    "file-type": "^18.5.0",
-    "nodemailer": "^7.0.12",
+    "file-type": "^18.7.0",
+    "nodemailer": "^7.0.13",
     "passport": "^0.7.0",
     "passport-facebook": "^3.0.0",
     "passport-github2": "^0.1.12",
@@ -56,23 +56,23 @@
     "passport-oauth2": "^1.8.0",
     "pg": "^8.15.6",
     "pg-cursor": "^2.17.0",
-    "pg-promise": "^12.6.0",
-    "prostgles-types": "^4.0.209"
+    "pg-promise": "^12.6.1",
+    "prostgles-types": "^4.0.211"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
-    "@types/express": "^4.17.21",
+    "@types/express": "^4.17.25",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^22.10.2",
-    "@types/nodemailer": "^6.4.17",
-    "@types/pg": "^8.15.1",
+    "@types/node": "^22.19.11",
+    "@types/nodemailer": "^6.4.22",
+    "@types/pg": "^8.16.0",
     "@types/pg-cursor": "^2.7.2",
-    "@types/sharp": "^0.30.4",
+    "@types/sharp": "^0.30.5",
     "eslint": "^9.39.2",
     "eslint-plugin-security": "^3.0.1",
-    "prettier": "^3.4.2",
-    "socket.io": "^4.8.1",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^8.38.0"
+    "prettier": "^3.8.1",
+    "socket.io": "^4.8.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.0"
   }
 }