prostgles-server 4.2.548 → 4.2.550

package/lib/DboBuilder/ViewHandler/size.ts

@@ -7,6 +7,7 @@ import {
   withUserRLS,
 } from "../dboBuilderUtils";
 import type { ViewHandler } from "./ViewHandler";
+import { getReturnTypeQuery } from "./getReturnTypeQuery";
 export async function size(
   this: ViewHandler,
   _filter?: Filter,
@@ -25,7 +26,7 @@ export async function size(
       table_rules,
       localParams,
     ).then(async (_allowed) => {
-      const q: string = (await this.find(
+      const selectQueryWithoutRLS = (await this.find(
         filter,
         {
           ...selectParams,
@@ -34,18 +35,31 @@ export async function size(
         undefined,
         table_rules,
         { ...localParams, returnQuery: "noRLS", bypassLimit: true },
-      )) as any;
-      const query = withUserRLS(
+      )) as unknown as string;
+
+      const queryWithoutUserRLS = `
+        SELECT sum(pg_column_size((prgl_size_query.*))) as size 
+        FROM (
+          ${selectQueryWithoutRLS}
+        ) prgl_size_query
+      `;
+      const queryWithRLS = withUserRLS(localParams, queryWithoutUserRLS);
+
+      const queryToReturn = await getReturnTypeQuery({
+        handler: this,
         localParams,
-        `${withUserRLS(localParams, "")}
-            SELECT sum(pg_column_size((prgl_size_query.*))) as size 
-            FROM (
-              ${q}
-            ) prgl_size_query
-          `,
-      );
+        queryWithoutRLS: queryWithoutUserRLS,
+        queryWithRLS,
+        returnType: selectParams?.returnType,
+        newQuery: undefined,
+      });
+      if (queryToReturn) {
+        return queryToReturn as unknown[];
+      }
 
-      return (this.tx?.t || this.db).one(query).then(({ size }) => size || "0");
+      return (this.tx?.t || this.db)
+        .one<{ size: string | null }>(queryWithRLS)
+        .then(({ size }) => size || "0");
     });
     await this._log({
       command: "size",
@@ -53,7 +67,7 @@ export async function size(
       data: { filter, selectParams },
       duration: Date.now() - start,
     });
-    return result;
+    return result as string;
   } catch (e) {
     await this._log({
       command: "size",

package/lib/DboBuilder/dboBuilderUtils.ts

@@ -96,7 +96,7 @@ export function getSerializedClientErrorFromPGError(
   }
   return errObject;
 }
-export function getClientErrorFromPGError(
+export function rejectWithPGClientError(
   rawError: any,
   args: GetSerializedClientErrorFromPGErrorArgs,
 ) {

package/lib/DboBuilder/parseUpdateRules.ts

@@ -171,7 +171,7 @@ export async function parseUpdateRules(
               rows: [data],
               allowedCols,
               dbTx: this.tx?.dbTX || this.dboBuilder.dbo,
-              tx: localParams?.tx?.t || this.tx?.t || this.db,
+              tx: this.getTransaction(localParams)?.t || this.db,
               validationOptions: {
                 validate: updateValidate,
                 localParams,

package/lib/PubSubManager/addSub.ts

@@ -87,12 +87,8 @@ export async function addSub(
 
   if (viewOptions) {
     for (const relatedTable of viewOptions.relatedTables) {
-      const quoteIdentTableName =
-        `"${relatedTable.tableName}"` !== relatedTable.tableNameEscaped ?
-          relatedTable.tableNameEscaped
-        : relatedTable.tableName;
       const relatedTrigger = {
-        table_name: quoteIdentTableName,
+        table_name: relatedTable.tableName,
         condition: parseCondition(relatedTable.condition),
         tracked_columns: relatedTable.tracked_columns,
       } satisfies AddTriggerParams;

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -60,6 +60,10 @@ export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
   dbx: DBX;
   tx: pgPromise.ITask<{}> | DB;
 } & (
+  | {
+      command: "delete";
+      data: unknown;
+    }
   | {
       command: "insert";
       data: R;
@@ -70,21 +74,57 @@ export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
     }
 );
 
+export type AfterEachTsTrigger<R, DBX> = {
+  commands: Partial<Record<"insert" | "update" | "delete", 1>>;
+  changedFields?: string[];
+  validate: (
+    params: ValidateRowArgsCommon<R, DBX> & {
+      localParams: undefined | LocalParams;
+    },
+  ) => Promise<void>;
+};
+
 export type ValidateRowsArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
+  /**
+   * The rows that were inserted/updated/deleted
+   * For delete the rows are the ones that were deleted (before delete)
+   * For insert the rows are the ones that were inserted (after insert)
+   * For update the rows are the ones that were updated (after update)
+   */
   rows: R[];
   dbx: DBX;
   tx: pgPromise.ITask<{}> | DB;
 } & (
+  | {
+      command: "delete";
+      data: unknown;
+    }
   | {
       command: "insert";
+      /**
+       * The data that was used to insert the rows.
+       */
       data: R[];
     }
   | {
       command: "update";
+      /**
+       * The data that was used to update the rows.
+       */
       data: Partial<R>[];
     }
 );
 
+export type AfterAllTsTrigger<R, DBX> = {
+  commands: Partial<Record<"insert" | "update" | "delete", 1>>;
+  changedFields?: string[];
+  validate: (
+    params: ValidateRowsArgsCommon<R, DBX> & {
+      localParams: undefined | LocalParams;
+    },
+  ) => Promise<void>;
+};
+
 export type ValidateRowArgs<R = AnyObject, DBX = DBHandlerServer> = ValidateRowArgsCommon<
   R,
   DBX
@@ -187,7 +227,8 @@ export type InsertRule<
   preValidate?: S extends DBSchema ? ValidateRow<Cols, S> : ValidateRowBasic;
 
   /**
-   * Validation logic to check/update data for each request. Happens after publish rule checks (for fields, forcedData/forcedFilter)
+   * Validation logic to check/update data for each request.
+   * Happens after publish rule checks (for fields, forcedData/forcedFilter) but before insert.
    */
   validate?: S extends DBSchema ? ValidateRow<Cols, S> : ValidateRowBasic;
 

package/lib/TableConfig/TableConfig.ts

@@ -14,6 +14,8 @@ import { uploadFile } from "../DboBuilder/uploadFile";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
 import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
 import type {
+  AfterAllTsTrigger,
+  AfterEachTsTrigger,
   InsertRule,
   SyncConfig,
   ValidateRowArgsCommon,
@@ -66,24 +68,8 @@ type BaseTableDefinition<R = AnyObject, DBX = DBHandlerServer> = {
     getPreInsertRow?: (
       args: GetPreInsertRowArgs,
     ) => Promise<{ row: AnyObject; onInserted: Promise<void> }>;
-    afterEach?: {
-      commands: Partial<Record<"insert" | "update", 1>>;
-      changedFields?: string[];
-      validate: (
-        params: ValidateRowArgsCommon<R, DBX> & {
-          localParams: undefined | LocalParams;
-        },
-      ) => Promise<void>;
-    }[];
-    afterAll?: {
-      commands: Partial<Record<"insert" | "update", 1>>;
-      changedFields?: string[];
-      validate: (
-        params: ValidateRowsArgsCommon<R, DBX> & {
-          localParams: undefined | LocalParams;
-        },
-      ) => Promise<void>;
-    }[];
+    afterEach?: AfterEachTsTrigger<R, DBX>[];
+    afterAll?: AfterAllTsTrigger<R, DBX>[];
   };
   triggers?: {
     [triggerName: string]: {

package/lib/utils/utils.ts

@@ -25,3 +25,5 @@ const canBeUsedAsIsInTypescript = (str: string): boolean => {
   const startsWithCharOrUnderscore = str[0]?.match(/^[a-z_]+$/i);
   return Boolean(isAlphaNumericOrUnderline && startsWithCharOrUnderscore);
 };
+
+export const isArray = <T>(data: T): data is Extract<T, readonly unknown[]> => Array.isArray(data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.548",
+  "version": "4.2.550",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",