prostgles-server 4.2.551 → 4.2.554

package/lib/Auth/AuthTypes.ts

@@ -98,11 +98,6 @@ export type SMTPConfig =
       region: string;
       accessKeyId: string;
       secretAccessKey: string;
-      /**
-       * Sending rate per second
-       * Defaults to 1
-       */
-      sendingRate?: number;
     };
 
 export type Email = {
@@ -310,7 +305,7 @@ export type AuthConfig<S = void, SUser extends SessionUser = SessionUser> = {
   onUseOrSocketConnected?: (
     sid: string | undefined,
     client: LoginClientInfo,
-    reqInfo: AuthClientRequest
+    reqInfo: AuthClientRequest,
   ) => Awaitable<void | { error: string; httpCode: 400 | 401 | 403 } | { session: BasicSession }>;
 
   /**
@@ -326,7 +321,7 @@ export type AuthConfig<S = void, SUser extends SessionUser = SessionUser> = {
     dbo: DBOFullyTyped<S>,
     db: DB,
     client: LoginClientInfo,
-    reqInfo: AuthClientRequest
+    reqInfo: AuthClientRequest,
   ) => Awaitable<AuthResultOrError<SUser>>;
 
   /**
@@ -381,7 +376,7 @@ export const getMagicLinkUrl = ({
   }
   const { code, email } = data;
   const confirmationUrl = new URL(
-    `${websiteUrl}${GET_AUTH_ROUTE(loginSignupConfig, "magicLinks")}`
+    `${websiteUrl}${GET_AUTH_ROUTE(loginSignupConfig, "magicLinks")}`,
   );
   confirmationUrl.searchParams.set("email", email);
   confirmationUrl.searchParams.set("code", code);
@@ -424,7 +419,7 @@ export type LoginSignupConfig<S, SUser extends SessionUser> = {
   onGetRequestOK?: (
     req: ExpressReq,
     res: ExpressRes,
-    params: AuthRequestParams<S, SUser>
+    params: AuthRequestParams<S, SUser>,
   ) => Awaitable<void>;
 
   /**
@@ -439,7 +434,7 @@ export type LoginSignupConfig<S, SUser extends SessionUser> = {
     data: MagicLinkOrOTPData,
     dbo: DBOFullyTyped<S>,
     db: DB,
-    client: LoginClientInfo
+    client: LoginClientInfo,
   ) => Awaitable<
     | {
         session: BasicSession | undefined;
@@ -470,7 +465,7 @@ export type LoginSignupConfig<S, SUser extends SessionUser> = {
     dbo: DBOFullyTyped<S>,
     db: DB,
     client: LoginClientInfo,
-    getMagicLinkUrl: (data: MagicLinkOrOTPData, websiteUrl: string) => string
+    getMagicLinkUrl: (data: MagicLinkOrOTPData, websiteUrl: string) => string,
   ) => Awaitable<LoginResponse>;
 
   logout: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<void>;

package/lib/Auth/sendEmail.ts

@@ -1,6 +1,6 @@
 import type { Email, SMTPConfig } from "./AuthTypes";
 import * as nodemailer from "nodemailer";
-import * as aws from "@aws-sdk/client-ses";
+import { SESv2Client, SendEmailCommand } from "@aws-sdk/client-sesv2";
 import type SESTransport from "nodemailer/lib/ses-transport";
 import { checkDmarc } from "./utils/checkDmarc";
 
@@ -17,8 +17,8 @@ const transporterCache: Map<string, Transporter> = new Map();
  * Allows sending emails using nodemailer default config or AWS SES
  * https://www.nodemailer.com/transports/ses/
  */
-const sendEmail = (smptConfig: SMTPConfig, email: Email) => {
-  const transporter = getOrSetTransporter(smptConfig);
+const sendEmail = (smtpConfig: SMTPConfig, email: Email) => {
+  const transporter = getOrSetTransporter(smtpConfig);
   return send(transporter, email);
 };
 
@@ -26,11 +26,11 @@ const sendEmail = (smptConfig: SMTPConfig, email: Email) => {
  * Verifies DMARC and that the website has a valid DMARC records
  */
 const emailSenderCache: Map<string, boolean> = new Map();
-export const getEmailSender = async (smptConfig: SMTPConfig, websiteUrl: string) => {
+export const getEmailSender = async (smtpConfig: SMTPConfig, websiteUrl: string) => {
   const result = {
-    sendEmail: (email: Email) => sendEmail(smptConfig, email),
+    sendEmail: (email: Email) => sendEmail(smtpConfig, email),
   };
-  const configStr = JSON.stringify({ smptConfig, websiteUrl });
+  const configStr = JSON.stringify({ smtpConfig, websiteUrl });
   if (emailSenderCache.has(configStr)) {
     return result;
   }
@@ -39,12 +39,12 @@ export const getEmailSender = async (smptConfig: SMTPConfig, websiteUrl: string)
   }
   await checkDmarc(websiteUrl);
 
-  await verifySMTPConfig(smptConfig);
+  await verifySMTPConfig(smtpConfig);
 
   /**
    * Setup nodemailer transporters
    */
-  getOrSetTransporter(smptConfig);
+  getOrSetTransporter(smtpConfig);
   emailSenderCache.set(configStr, true);
   return result;
 };
@@ -52,28 +52,20 @@ export const getEmailSender = async (smptConfig: SMTPConfig, websiteUrl: string)
 /**
  * Returns a transporter from cache or creates a new one
  */
-export const getOrSetTransporter = (smptConfig: SMTPConfig) => {
-  const configStr = JSON.stringify(smptConfig);
-  const transporter = transporterCache.get(configStr) ?? getTransporter(smptConfig);
+export const getOrSetTransporter = (smtpConfig: SMTPConfig) => {
+  const configStr = JSON.stringify(smtpConfig);
+  const transporter = transporterCache.get(configStr) ?? getTransporter(smtpConfig);
   if (!transporterCache.has(configStr)) {
     transporterCache.set(configStr, transporter);
   }
   return transporter;
 };
 
-const getTransporter = (smptConfig: SMTPConfig) => {
+const getTransporter = (smtpConfig: SMTPConfig) => {
   let transporter: Transporter | undefined;
-  if (smptConfig.type === "aws-ses") {
-    const {
-      region,
-      accessKeyId,
-      secretAccessKey,
-      /**
-       * max 1 messages/second
-       */
-      sendingRate = 1,
-    } = smptConfig;
-    const ses = new aws.SES({
+  if (smtpConfig.type === "aws-ses") {
+    const { region, accessKeyId, secretAccessKey } = smtpConfig;
+    const sesClient = new SESv2Client({
       apiVersion: "2010-12-01",
       region,
       credentials: {
@@ -83,12 +75,13 @@ const getTransporter = (smptConfig: SMTPConfig) => {
     });
 
     transporter = nodemailer.createTransport({
-      SES: { ses, aws },
-      maxConnections: 1,
-      sendingRate,
+      SES: {
+        sesClient,
+        SendEmailCommand,
+      },
     });
   } else {
-    const { user, pass, host, port, secure, tls } = smptConfig;
+    const { user, pass, host, port, secure, tls } = smtpConfig;
     transporter = nodemailer.createTransport({
       host,
       port,
@@ -126,8 +119,8 @@ const send = (transporter: Transporter, email: Email) => {
   });
 };
 
-export const verifySMTPConfig = async (smptConfig: SMTPConfig) => {
-  const transporter = getOrSetTransporter(smptConfig);
+export const verifySMTPConfig = async (smtpConfig: SMTPConfig) => {
+  const transporter = getOrSetTransporter(smtpConfig);
   return new Promise((resolve, reject) => {
     transporter.verify((err, success) => {
       if (err) {

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -34,6 +34,7 @@ import { insert } from "./insert/insert";
 import { update } from "./update";
 import { updateBatch } from "./updateBatch";
 import { upsert } from "./upsert";
+import { isApplicableHook } from "./isApplicableHook";
 
 export type ValidatedParams = {
   row: AnyObject;
@@ -71,7 +72,49 @@ export class TableHandler extends ViewHandler {
     this.is_media = dboBuilder.prostgles.isMedia(this.name);
   }
 
-  getHooksAndChecks = (
+  getBeforeHooks = (command: "update" | "insert", rows: AnyObject[]) => {
+    return (
+      this.config?.hooks?.beforeEach?.filter((hook) =>
+        isApplicableHook(this, rows, hook, command),
+      ) ?? []
+    );
+  };
+
+  beforeEach = async (
+    row: AnyObject,
+    localParams: LocalParams | undefined,
+    command: "insert" | "update",
+  ) => {
+    const transaction = this.getTransaction(localParams);
+    const hooks = this.getBeforeHooks(command, [row]);
+    let newRow = row;
+    const successCallbacks: (() => void)[] = [];
+    for (const hook of hooks) {
+      const isApplicable = isApplicableHook(this, [newRow], hook, command);
+      if (!isApplicable) continue;
+      const hookResult = await hook.validate({
+        row: newRow,
+        command: "insert",
+        data: newRow,
+        dbx: this.getFinalDbo(localParams),
+        localParams,
+        tx: transaction?.t || this.db,
+      });
+      if (hookResult) {
+        newRow = hookResult.row;
+        const { onInserted } = hookResult;
+        if (onInserted) {
+          successCallbacks.push(onInserted);
+        }
+      }
+    }
+    return {
+      row: newRow,
+      successCallbacks,
+    };
+  };
+
+  getAfterHooksAndChecks = (
     command:
       | { name: "delete"; rule: undefined | DeleteRule }
       | { name: "update"; rule: undefined | UpdateRule }
@@ -109,8 +152,12 @@ export class TableHandler extends ViewHandler {
       .filter(isDefined);
     return [
       ...(afterEachHooks ?? []),
-      ...(postValidate ? [{ type: "postValidate", validate: postValidate } as const] : []),
-      ...(checkFilter ? [{ type: "checkFilter", checkFilter } as const] : []),
+      ...(postValidate ?
+        [{ type: "postValidate", validate: postValidate, changedFields: undefined } as const]
+      : []),
+      ...(checkFilter ?
+        [{ type: "checkFilter", checkFilter, changedFields: undefined } as const]
+      : []),
       ...(afterAllHooks ?? []),
     ];
   };
@@ -120,10 +167,17 @@ export class TableHandler extends ViewHandler {
       | { name: "update"; rule: undefined | UpdateRule }
       | { name: "insert"; rule: undefined | InsertRule },
     localParams: LocalParams | undefined,
+    newRows: AnyObject[],
   ) => {
     const transaction = this.getTransaction(localParams);
-    const hasAfterChecks = this.getHooksAndChecks(command, localParams).length > 0;
-    return { shouldWrap: !transaction && hasAfterChecks, hasAfterChecks };
+    const hasAfterChecks = this.getAfterHooksAndChecks(command, localParams).length > 0;
+    const hasBeforeHooks =
+      command.name !== "delete" && this.getBeforeHooks(command.name, newRows).length > 0;
+    return {
+      shouldWrap: !transaction && (hasAfterChecks || hasBeforeHooks),
+      hasBeforeHooks,
+      hasAfterChecks,
+    };
   };
   getFinalDbo = (localParams: LocalParams | undefined) => {
     return this.getTransaction(localParams)?.dbTX ?? this.dboBuilder.dbo;

package/lib/DboBuilder/TableHandler/delete.ts

@@ -11,7 +11,7 @@ import {
 import type { TableHandler } from "./TableHandler";
 import { onDeleteFromFileTable } from "./onDeleteFromFileTable";
 import { getReturnTypeQuery } from "../ViewHandler/getReturnTypeQuery";
-import { executeHooksCheckAndPostValidation } from "./executeHooksCheckAndPostValidation";
+import { executeAfterHooksCheckAndPostValidation } from "./executeAfterHooksCheckAndPostValidation";
 
 export async function _delete(
   this: TableHandler,
@@ -28,7 +28,7 @@ export async function _delete(
     this.checkFilter(filter);
 
     const operation = { name: "delete", rule: tableRules?.delete } as const;
-    const { hasAfterChecks, shouldWrap } = this.shouldWrapInTx(operation, localParams);
+    const { hasAfterChecks, shouldWrap } = this.shouldWrapInTx(operation, localParams, []);
     if (shouldWrap) {
       return this.dboBuilder.getTX((t) =>
         (t[this.name] as Partial<typeof this> | undefined)?.delete?.(
@@ -183,7 +183,7 @@ export async function _delete(
         return fullRow;
       });
 
-      await executeHooksCheckAndPostValidation({
+      await executeAfterHooksCheckAndPostValidation({
         tableHandler: this,
         operation,
         localParams,

package/lib/DboBuilder/TableHandler/{executeHooksCheckAndPostValidation.ts → executeAfterHooksCheckAndPostValidation.ts}

@@ -3,8 +3,9 @@ import type { DeleteRule, InsertRule, UpdateRule } from "../../PublishParser/Pub
 import { isArray } from "../../utils/utils";
 import type { LocalParams } from "../DboBuilder";
 import type { TableHandler } from "./TableHandler";
+import { isApplicableHook } from "./isApplicableHook";
 
-export const executeHooksCheckAndPostValidation = async ({
+export const executeAfterHooksCheckAndPostValidation = async ({
   tableHandler,
   operation,
   data,
@@ -22,22 +23,13 @@ export const executeHooksCheckAndPostValidation = async ({
 }) => {
   const command = operation.name;
   const transaction = tableHandler.getTransaction(localParams);
-  const hooks = tableHandler.getHooksAndChecks(operation, localParams);
-  let changedFieldsSet = undefined as undefined | Set<string>;
-  const getChangedFieldsSet = () => {
-    changedFieldsSet ??= new Set<string>(
-      (isArray(data) ? data : [data]).map((row) => Object.keys(row)).flat(),
-    );
-    return changedFieldsSet;
-  };
+  const hooks = tableHandler.getAfterHooksAndChecks(operation, localParams);
+  const newRows = isArray(data) ? data : [data];
+
   const applicableHooks = hooks.filter((hook) => {
     if (hook.type === "checkFilter") return false;
     if (hook.type === "postValidate") return true;
-    const { commands, changedFields } = hook;
-    return (
-      commands[command] &&
-      (!changedFields || changedFields.some((f) => getChangedFieldsSet().has(f)))
-    );
+    return isApplicableHook(tableHandler, newRows, hook, command);
   });
 
   if (applicableHooks.length) {
@@ -58,6 +50,13 @@ export const executeHooksCheckAndPostValidation = async ({
         data,
       } as const;
       for (const hook of applicableHooks) {
+        const isApplicable = isApplicableHook(
+          tableHandler,
+          [row],
+          { commands: { [command]: 1 }, changedFields: hook.changedFields },
+          command,
+        );
+        if (!isApplicable) continue;
         if (hook.type === "afterEach") {
           await hook.validate({
             ...commonParams,
@@ -74,12 +73,22 @@ export const executeHooksCheckAndPostValidation = async ({
     }
 
     for (const hook of applicableHooks) {
+      const applicableRows = newRows.filter((row) => {
+        const isApplicable = isApplicableHook(
+          tableHandler,
+          [row],
+          { commands: { [command]: 1 }, changedFields: hook.changedFields },
+          command,
+        );
+        return isApplicable;
+      });
+      if (!applicableRows.length) continue;
       if (hook.type === "afterAll") {
         await hook.validate({
           ...txParams,
           command,
-          data: Array.isArray(data) ? data : [data],
-          rows,
+          data: newRows,
+          rows: applicableRows,
           localParams,
         });
       }

package/lib/DboBuilder/TableHandler/insert/insert.ts

@@ -14,6 +14,7 @@ import { insertTest } from "../insertTest";
 import { runInsertUpdateQuery } from "../runInsertUpdateQuery";
 import { insertNestedRecords } from "./insertNestedRecords";
 import { getReturnTypeQuery } from "../../ViewHandler/getReturnTypeQuery";
+import { isArray } from "../../../utils/utils";
 
 export async function insert(
   this: TableHandler,
@@ -34,7 +35,13 @@ export async function insert(
 
     const finalDBtx = this.getTransaction(localParams);
     /** Post validate and checkFilter require a transaction dbo handler because they need the action result */
-    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams).shouldWrap) {
+    if (
+      this.shouldWrapInTx(
+        { name: ACTION, rule },
+        localParams,
+        isArray(rowOrRows) ? rowOrRows : [rowOrRows],
+      ).shouldWrap
+    ) {
       return this.dboBuilder.getTX((t) =>
         t[this.name]?.[ACTION](rowOrRows, insertParams, param3_unused, tableRules, localParams),
       );
@@ -59,8 +66,8 @@ export async function insert(
         throw `Direct inserts not allowed. Only nested inserts from these tables: ${JSON.stringify(allowedNestedInserts)} `;
       }
     }
-    const isMultiInsert = Array.isArray(rowOrRows);
-    const rows = isMultiInsert ? (rowOrRows as AnyObject[]) : [rowOrRows];
+    const isMultiInsert = isArray(rowOrRows);
+    const rows = isMultiInsert ? rowOrRows : [rowOrRows];
 
     requiredNestedInserts?.forEach(({ ftable, maxRows, minRows }) => {
       if (this.column_names.includes(ftable))
@@ -69,7 +76,7 @@ export async function insert(
         const nestedInsert = row[ftable] as unknown;
         const nestedInsertRows =
           isObject(nestedInsert) ? [nestedInsert]
-          : Array.isArray(nestedInsert) ? nestedInsert
+          : isArray(nestedInsert) ? nestedInsert
           : [];
         if (!nestedInsertRows.length) {
           throw `Missing required nested insert on rowId ${rowId} for ftable: ${ftable}`;
@@ -85,15 +92,17 @@ export async function insert(
 
     validateInsertParams(insertParams);
 
-    // const tx = localParams?.tx?.t || this.tx?.t;
     const transaction = this.getTransaction(localParams);
     const tx = transaction?.t || this.db;
 
+    const successCallbacks: (() => void)[] = [];
     const preValidatedRows = await Promise.all(
       rows.map(async (nonValidated) => {
         const { preValidate, validate } = rule ?? {};
         const { tableConfigurator } = this.dboBuilder.prostgles;
-        if (!tableConfigurator) throw "tableConfigurator missing";
+        if (!tableConfigurator) {
+          throw "tableConfigurator missing";
+        }
         let row = await tableConfigurator.getPreInsertRow(this, {
           dbx: this.getFinalDbo(localParams),
           validate,
@@ -103,6 +112,11 @@ export async function insert(
           command: "insert",
           data: nonValidated,
         });
+
+        const beforeResult = await this.beforeEach(row, localParams, "insert");
+        row = beforeResult.row;
+        beforeResult.successCallbacks.forEach((cb) => successCallbacks.push(cb));
+
         if (preValidate) {
           if (!localParams) {
             throw "localParams missing for insert preValidate";
@@ -269,7 +283,7 @@ export async function insert(
       data: { rowOrRows, param2: insertParams },
       duration: Date.now() - start,
     });
-
+    successCallbacks.forEach((cb) => cb());
     return result;
   } catch (e) {
     await this._log({

package/lib/DboBuilder/TableHandler/isApplicableHook.ts

@@ -0,0 +1,28 @@
+import type { AnyObject } from "prostgles-types";
+import type { AfterEachTsTrigger } from "../../PublishParser/PublishParser";
+import type { TableHandler } from "./TableHandler";
+
+export const isApplicableHook = (
+  tableHandler: TableHandler,
+  rows: AnyObject[],
+  hook: Pick<AfterEachTsTrigger<AnyObject, any>, "commands" | "changedFields">,
+  command: "insert" | "update" | "delete",
+) => {
+  let changedFieldsSet = undefined as undefined | Set<string>;
+  const getChangedFieldsSet = () => {
+    changedFieldsSet ??= new Set(
+      tableHandler.column_names.filter((col) =>
+        rows.some((row) => row[col] !== undefined && row[col] !== null),
+      ),
+    );
+    return changedFieldsSet;
+  };
+
+  const { commands, changedFields } = hook;
+  return Boolean(
+    commands[command] &&
+    (command === "delete" ||
+      !changedFields ||
+      changedFields.some((f) => getChangedFieldsSet().has(f))),
+  );
+};

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -5,7 +5,7 @@ import type { LocalParams } from "../DboBuilder";
 import { rejectWithPGClientError, withUserRLS } from "../DboBuilder";
 import type { TableHandler } from "./TableHandler";
 import { getSelectItemQuery } from "./TableHandler";
-import { executeHooksCheckAndPostValidation } from "./executeHooksCheckAndPostValidation";
+import { executeAfterHooksCheckAndPostValidation } from "./executeAfterHooksCheckAndPostValidation";
 
 type RunInsertUpdateQueryArgs = {
   tableHandler: TableHandler;
@@ -126,7 +126,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
 
   const rows = result.modified ?? [];
 
-  await executeHooksCheckAndPostValidation({
+  await executeAfterHooksCheckAndPostValidation({
     tableHandler,
     operation: command === "insert" ? { name: "insert", rule } : { name: "update", rule },
     localParams,

package/lib/DboBuilder/TableHandler/update.ts

@@ -33,7 +33,7 @@ export async function update(
         ),
       );
     const rule = tableRules?.[ACTION];
-    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams).shouldWrap) {
+    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams, [_newData]).shouldWrap) {
       return wrapInTx();
     }
 
@@ -76,6 +76,9 @@ export async function update(
         );
     }
 
+    const beforeResult = await this.beforeEach(newData, localParams, "update");
+    newData = beforeResult.row;
+
     const { data, allowedCols } = prepareNewData({
       row: newData,
       forcedData,
@@ -205,6 +208,7 @@ export async function update(
       data: { filter, _newData, params },
       duration: Date.now() - start,
     });
+    beforeResult.successCallbacks.forEach((cb) => cb());
     return result;
   } catch (e) {
     await this._log({

package/lib/FileManager/FileManager.ts

@@ -333,7 +333,7 @@ export const getFileType = async (
   >);
 
   const fileNameMime = getFileTypeFromFilename(fileName);
-  if (!fileNameMime?.ext) throw new Error("File name must contain extenion");
+  if (!fileNameMime?.ext) throw new Error("File name must contain extension");
   const res = await fileTypeFromBuffer(typeof file === "string" ? Buffer.from(file, "utf8") : file);
 
   if (!res) {

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -55,6 +55,20 @@ export type UpdateRequestData<R extends AnyObject = AnyObject> =
   | UpdateRequestDataOne<R>
   | UpdateRequestDataBatch<R>;
 
+export type ValidateBeforeRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
+  row: R;
+  dbx: DBX;
+  tx: pgPromise.ITask<{}> | DB;
+} & (
+  | {
+      command: "insert";
+      data: R;
+    }
+  | {
+      command: "update";
+      data: Partial<R>;
+    }
+);
 export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
   row: R;
   dbx: DBX;
@@ -74,9 +88,25 @@ export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
     }
 );
 
+export type BeforeEachTsTrigger<R, DBX> = {
+  commands: Partial<Record<"insert" | "update", 1>>;
+  /**
+   * Will only run this trigger if the insert/update provides non null values for these fields.
+   */
+  changedFields?: (keyof R)[];
+  validate: (
+    params: ValidateBeforeRowArgsCommon<R, DBX> & {
+      localParams: undefined | LocalParams;
+    },
+  ) => Promise<void | { row: R; onInserted?: () => void }>;
+};
+
 export type AfterEachTsTrigger<R, DBX> = {
   commands: Partial<Record<"insert" | "update" | "delete", 1>>;
-  changedFields?: string[];
+  /**
+   * Will only run this trigger if the insert/update provides non null values for these fields.
+   */
+  changedFields?: (keyof R)[];
   validate: (
     params: ValidateRowArgsCommon<R, DBX> & {
       localParams: undefined | LocalParams;

package/lib/TableConfig/TableConfig.ts

@@ -16,10 +16,10 @@ import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
 import type {
   AfterAllTsTrigger,
   AfterEachTsTrigger,
+  BeforeEachTsTrigger,
   InsertRule,
   SyncConfig,
   ValidateRowArgsCommon,
-  ValidateRowsArgsCommon,
 } from "../PublishParser/PublishParser";
 import {
   DEFAULT_SYNC_BATCH_SIZE,
@@ -63,11 +63,12 @@ type BaseTableDefinition<R = AnyObject, DBX = DBHandlerServer> = {
   hooks?: {
     /**
      * Hook used to run custom logic before inserting a row.
-     * The returned row must satisfy the table schema
+     * The returned row must satisfy the table schema.
      */
     getPreInsertRow?: (
       args: GetPreInsertRowArgs,
     ) => Promise<{ row: AnyObject; onInserted: Promise<void> }>;
+    beforeEach?: BeforeEachTsTrigger<R, DBX>[];
     afterEach?: AfterEachTsTrigger<R, DBX>[];
     afterAll?: AfterAllTsTrigger<R, DBX>[];
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "4.2.551",
+  "version": "4.2.554",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,8 +38,8 @@
   ],
   "homepage": "https://prostgles.com",
   "dependencies": {
-    "@aws-sdk/client-ses": "^3.1069.0",
-    "@aws-sdk/credential-provider-node": "^3.972.56",
+    "@aws-sdk/client-sesv2": "^3.1090.0",
+    "@aws-sdk/credential-provider-node": "^3.972.70",
     "@types/passport": "^1.0.17",
     "@types/passport-facebook": "^3.0.4",
     "@types/passport-github2": "^1.2.9",
@@ -47,7 +47,7 @@
     "@types/passport-microsoft": "^1.0.3",
     "check-disk-space": "^3.4.0",
     "file-type": "^18.7.0",
-    "nodemailer": "^7.0.13",
+    "nodemailer": "^9.0.3",
     "passport": "^0.7.0",
     "passport-facebook": "^3.0.0",
     "passport-github2": "^0.1.12",
@@ -55,24 +55,24 @@
     "passport-microsoft": "^2.1.0",
     "passport-oauth2": "^1.8.0",
     "pg": "^8.21.0",
-    "pg-cursor": "^2.20.0",
-    "pg-promise": "^12.6.2",
+    "pg-cursor": "^2.21.0",
+    "pg-promise": "^12.7.0",
     "prostgles-types": "^4.0.264"
   },
   "devDependencies": {
     "@eslint/js": "^9.22.0",
     "@types/express": "^4.17.25",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^22.19.21",
-    "@types/nodemailer": "^6.4.24",
+    "@types/node": "^22.20.1",
+    "@types/nodemailer": "^8.0.1",
     "@types/pg": "^8.20.0",
     "@types/pg-cursor": "^2.7.2",
     "@types/sharp": "^0.30.5",
-    "eslint": "^9.39.4",
+    "eslint": "^9.39.5",
     "eslint-plugin-security": "^3.0.1",
-    "prettier": "^3.8.4",
+    "prettier": "^3.9.5",
     "socket.io": "^4.8.3",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.61.1"
+    "typescript-eslint": "^8.64.0"
   }
 }