prostgles-server 4.2.470 → 4.2.472

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -7,9 +7,15 @@ import type {
   Select,
   UpdateParams,
 } from "prostgles-types";
-import { asName } from "prostgles-types";
+import { asName, isDefined } from "prostgles-types";
 import type { DB } from "../../Prostgles";
-import type { SyncRule, ParsedTableRule } from "../../PublishParser/PublishParser";
+import type {
+  SyncRule,
+  ParsedTableRule,
+  InsertRule,
+  UpdateRule,
+  DeleteRule,
+} from "../../PublishParser/PublishParser";
 import type TableConfigurator from "../../TableConfig/TableConfig";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
 import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../DboBuilder";
@@ -26,6 +32,7 @@ import { update } from "./update";
 import { updateBatch } from "./updateBatch";
 import { upsert } from "./upsert";
 import { COMPUTED_FIELDS } from "../QueryBuilder/Functions/COMPUTED_FIELDS";
+import type { TableDefinition } from "../../TableConfig/TableConfig";
 
 export type ValidatedParams = {
   row: AnyObject;
@@ -39,14 +46,22 @@ export type ValidatedParams = {
 
 export class TableHandler extends ViewHandler {
   dataValidator: DataValidator;
-  constructor(
-    db: DB,
-    tableOrViewInfo: TableSchema,
-    dboBuilder: DboBuilder,
-    tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
-    joinPaths?: JoinPaths
-  ) {
-    super(db, tableOrViewInfo, dboBuilder, tx, joinPaths);
+  constructor({
+    db,
+    config,
+    dboBuilder,
+    tableOrViewInfo,
+    tx,
+    joinPaths,
+  }: {
+    db: DB;
+    tableOrViewInfo: TableSchema;
+    dboBuilder: DboBuilder;
+    config: TableDefinition<any> | undefined;
+    tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers };
+    joinPaths?: JoinPaths;
+  }) {
+    super({ db, tableOrViewInfo, dboBuilder, config, tx, joinPaths });
 
     // eslint-disable-next-line @typescript-eslint/unbound-method
     this.remove = this.delete;
@@ -59,6 +74,55 @@ export class TableHandler extends ViewHandler {
   getFinalDBtx = (localParams: LocalParams | undefined) => {
     return localParams?.tx?.dbTX ?? this.tx?.dbTX;
   };
+
+  getHooksAndChecks = (
+    command:
+      | { name: "update"; rule: undefined | UpdateRule }
+      | { name: "insert"; rule: undefined | InsertRule },
+  ) => {
+    const { checkFilter, postValidate } = command.rule ?? {};
+    const afterEachHooks = this.config?.hooks?.afterEach
+      ?.map((hook) => {
+        const { commands } = hook;
+        if (!commands[command.name]) {
+          return;
+        }
+        return {
+          type: "afterEach",
+          ...hook,
+        } as const;
+      })
+      .filter(isDefined);
+
+    const afterAllHooks = this.config?.hooks?.afterAll
+      ?.map((hook) => {
+        const { commands } = hook;
+        if (!commands[command.name]) {
+          return;
+        }
+        return {
+          type: "afterAll",
+          ...hook,
+        } as const;
+      })
+      .filter(isDefined);
+    return [
+      ...(afterEachHooks ?? []),
+      ...(postValidate ? [{ type: "postValidate", validate: postValidate } as const] : []),
+      ...(checkFilter ? [{ type: "checkFilter", checkFilter } as const] : []),
+      ...(afterAllHooks ?? []),
+    ];
+  };
+  shouldWrapInTx = (
+    command:
+      | { name: "update"; rule: undefined | UpdateRule }
+      | { name: "insert"; rule: undefined | InsertRule },
+    localParams: LocalParams | undefined,
+  ) => {
+    const finalDBtx = this.getFinalDBtx(localParams);
+    const hasAfterChecks = this.getHooksAndChecks(command).length > 0;
+    return !finalDBtx && hasAfterChecks;
+  };
   getFinalDbo = (localParams: LocalParams | undefined) => {
     return this.getFinalDBtx(localParams) ?? this.dboBuilder.dbo;
   };
@@ -73,14 +137,14 @@ export class TableHandler extends ViewHandler {
     param2?: InsertParams,
     param3_unused?: undefined,
     tableRules?: ParsedTableRule,
-    _localParams?: LocalParams
+    _localParams?: LocalParams,
   ): Promise<any> {
     return insert.bind(this)(rowOrRows, param2, param3_unused, tableRules, _localParams);
   }
 
   prepareReturning = async (
     returning: Select | undefined,
-    allowedFields: string[]
+    allowedFields: string[],
   ): Promise<SelectItemValidated[]> => {
     const result: SelectItemValidated[] = [];
     if (returning) {
@@ -111,7 +175,7 @@ export class TableHandler extends ViewHandler {
     params?: DeleteParams,
     param3_unused?: undefined,
     table_rules?: ParsedTableRule,
-    localParams?: LocalParams
+    localParams?: LocalParams,
   ): Promise<any> {
     return _delete.bind(this)(filter, params, param3_unused, table_rules, localParams);
   }
@@ -121,7 +185,7 @@ export class TableHandler extends ViewHandler {
     params?: UpdateParams,
     param3_unused?: undefined,
     tableRules?: ParsedTableRule,
-    localParams?: LocalParams
+    localParams?: LocalParams,
   ) {
     return this.delete(filter, params, param3_unused, tableRules, localParams);
   }
@@ -134,7 +198,7 @@ export class TableHandler extends ViewHandler {
     params: { select?: FieldFilter },
     param3_unused: undefined,
     table_rules: ParsedTableRule,
-    localParams: LocalParams
+    localParams: LocalParams,
   ) {
     const start = Date.now();
     try {
@@ -187,7 +251,7 @@ export class TableHandler extends ViewHandler {
         { select, limit: 0 },
         undefined,
         table_rules,
-        localParams
+        localParams,
       ).then(async (_isValid) => {
         const { filterFields, forcedFilter } = table_rules.select || {};
         const condition = (

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

@@ -28,24 +28,21 @@ export async function insert(
     const { removeDisallowedFields = false } = insertParams ?? {};
     const { returnQuery = false, nestedInsert } = localParams ?? {};
 
-    const finalDBtx = this.getFinalDBtx(localParams);
     const rule = tableRules?.[ACTION];
-    const { postValidate, checkFilter, validate, allowedNestedInserts, requiredNestedInserts } =
-      rule ?? {};
+    const { validate, allowedNestedInserts, requiredNestedInserts } = rule ?? {};
 
+    const finalDBtx = this.getFinalDBtx(localParams);
     /** Post validate and checkFilter require a transaction dbo handler because they happen after the insert */
-    if (postValidate || checkFilter) {
-      if (!finalDBtx) {
-        return this.dboBuilder.getTX((_dbtx) =>
-          _dbtx[this.name]?.[ACTION]?.(
-            rowOrRows,
-            insertParams,
-            param3_unused,
-            tableRules,
-            localParams,
-          ),
-        );
-      }
+    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams)) {
+      return this.dboBuilder.getTX((_dbtx) =>
+        _dbtx[this.name]?.[ACTION]?.(
+          rowOrRows,
+          insertParams,
+          param3_unused,
+          tableRules,
+          localParams,
+        ),
+      );
     }
 
     const { testOnly, fields, forcedData, returningFields } = await insertTest.bind(this)({

package/lib/DboBuilder/TableHandler/runInsertUpdateQuery.ts

@@ -17,7 +17,7 @@ type RunInsertUpdateQueryArgs = {
       command: "insert";
       params: InsertParams | undefined;
       rule: InsertRule | undefined;
-      data: AnyObject;
+      data: AnyObject | AnyObject[];
       isMultiInsert: boolean;
       nestedInsertsResultsObj?: undefined;
     }
@@ -49,7 +49,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
     params?.returning,
     tableHandler.parseFieldFilter(returningFields),
   );
-  const { checkFilter, postValidate } = rule ?? {};
+  const { checkFilter } = rule ?? {};
   let checkCondition = "WHERE FALSE";
   if (checkFilter) {
     const checkCond = await tableHandler.prepareWhere({
@@ -111,7 +111,7 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
 
   const tx = localParams?.tx?.t || tableHandler.tx?.t;
   if (tx) {
-    result = await tx[queryType](query).catch((err: any) =>
+    result = await tx[queryType](query).catch((err: unknown) =>
       getClientErrorFromPGError(err, {
         type: "tableMethod",
         localParams,
@@ -138,21 +138,69 @@ export const runInsertUpdateQuery = async (args: RunInsertUpdateQueryArgs) => {
     );
   }
 
+  const rows = result.modified ?? [];
   const finalDBtx = tableHandler.getFinalDBtx(localParams);
-  if (postValidate) {
-    if (!finalDBtx) throw new Error("Unexpected: no dbTX for postValidate");
-    if (!localParams) throw new Error("Unexpected: no localParams for postValidate");
+  const { postValidate } = rule ?? {};
+  const hooks = tableHandler.getHooksAndChecks(
+    command === "insert" ? { name: command, rule } : { name: command, rule },
+  );
+  let changedFieldsSet = undefined as undefined | Set<string>;
+  const getChangedFieldsSet = () => {
+    changedFieldsSet ??= new Set<string>(rows.map((row) => Object.keys(row)).flat());
+    return changedFieldsSet;
+  };
+  const applicableHooks = hooks.filter((hook) => {
+    if (hook.type === "checkFilter") return;
+    if (hook.type === "postValidate") return true;
+    const { commands, changedFields } = hook;
+    return (
+      commands[command] &&
+      (!changedFields || changedFields.some((f) => getChangedFieldsSet().has(f)))
+    );
+  });
+
+  if (postValidate && !localParams) {
+    throw new Error("Unexpected: no localParams for postValidate");
+  }
+
+  if (applicableHooks.length) {
+    if (!finalDBtx) throw new Error("Unexpected: no dbTX for hooks/postValidate");
 
-    const rows = result.modified ?? [];
     for (const row of rows) {
-      await postValidate({
+      const commonParams = {
         row: row,
         tx: tx || tableHandler.db,
         dbx: finalDBtx,
-        localParams,
         command,
         data,
-      });
+      } as const;
+      for (const hook of applicableHooks) {
+        if (hook.type === "afterEach") {
+          await hook.validate({
+            ...commonParams,
+            localParams,
+          });
+        } else if (hook.type === "postValidate") {
+          if (!localParams) throw new Error("Unexpected: no localParams for postValidate");
+          await hook.validate({
+            ...commonParams,
+            localParams,
+          });
+        }
+      }
+    }
+
+    for (const hook of applicableHooks) {
+      if (hook.type === "afterAll") {
+        await hook.validate({
+          tx: tx || tableHandler.db,
+          dbx: finalDBtx,
+          command,
+          data: Array.isArray(data) ? data : [data],
+          rows,
+          localParams,
+        });
+      }
     }
   }
 

package/lib/DboBuilder/TableHandler/update.ts

@@ -32,7 +32,7 @@ export async function update(
         ),
       );
     const rule = tableRules?.[ACTION];
-    if (rule?.postValidate && !finalDBtx) {
+    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams)) {
       return wrapInTx();
     }
 

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -28,6 +28,7 @@ import type { OnData } from "./subscribe";
 import { subscribe } from "./subscribe";
 import { validateViewRules } from "./validateViewRules";
 import { escapeTSNames } from "../../utils/utils";
+import type { TableDefinition } from "../../TableConfig/TableConfig";
 
 export type JoinPaths = {
   t1: string;
@@ -48,6 +49,7 @@ export class ViewHandler {
   joinGraph?: Graph;
   joinPaths?: JoinPaths;
   dboBuilder: DboBuilder;
+  config: TableDefinition<any> | undefined;
 
   tx?: {
     t: pgPromise.ITask<{}>;
@@ -60,13 +62,22 @@ export class ViewHandler {
   is_view = true;
   filterDef = "";
   is_media = false;
-  constructor(
-    db: DB,
-    tableOrViewInfo: TableSchema,
-    dboBuilder: DboBuilder,
-    tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers },
-    joinPaths?: JoinPaths,
-  ) {
+  constructor({
+    db,
+    config,
+    dboBuilder,
+    tableOrViewInfo,
+    tx,
+    joinPaths,
+  }: {
+    db: DB;
+    tableOrViewInfo: TableSchema;
+    dboBuilder: DboBuilder;
+    config: TableDefinition<any> | undefined;
+    tx?: { t: pgPromise.ITask<{}>; dbTX: TableHandlers };
+    joinPaths?: JoinPaths;
+  }) {
+    this.config = config;
     this.db = db;
     this.tx = tx;
     this.joinPaths = joinPaths;

package/lib/PublishParser/publishTypesAndUtils.ts

@@ -181,7 +181,6 @@ export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
   row: R;
   dbx: DBX;
   tx: pgPromise.ITask<{}> | DB;
-  localParams: LocalParams;
 } & (
   | {
       command: "insert";
@@ -193,6 +192,27 @@ export type ValidateRowArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
     }
 );
 
+export type ValidateRowsArgsCommon<R = AnyObject, DBX = DBHandlerServer> = {
+  rows: R[];
+  dbx: DBX;
+  tx: pgPromise.ITask<{}> | DB;
+} & (
+  | {
+      command: "insert";
+      data: R[];
+    }
+  | {
+      command: "update";
+      data: Partial<R>[];
+    }
+);
+
+export type ValidateRowArgs<R = AnyObject, DBX = DBHandlerServer> = ValidateRowArgsCommon<
+  R,
+  DBX
+> & {
+  localParams: LocalParams;
+};
 export type ValidateUpdateRowArgs<U = Partial<AnyObject>, F = Filter, DBX = DBHandlerServer> = {
   update: U;
   filter: F;
@@ -200,13 +220,13 @@ export type ValidateUpdateRowArgs<U = Partial<AnyObject>, F = Filter, DBX = DBHa
   localParams: LocalParams;
 };
 export type ValidateRow<R extends AnyObject = AnyObject, S = void> = (
-  args: ValidateRowArgsCommon<R, DBOFullyTyped<S>>,
+  args: ValidateRowArgs<R, DBOFullyTyped<S>>,
 ) => R | Promise<R>;
 export type PostValidateRow<R extends AnyObject = AnyObject, S = void> = (
-  args: ValidateRowArgsCommon<R, DBOFullyTyped<S>>,
+  args: ValidateRowArgs<R, DBOFullyTyped<S>>,
 ) => void | Promise<void>;
-export type PostValidateRowBasic = (args: ValidateRowArgsCommon) => void | Promise<void>;
-export type ValidateRowBasic = (args: ValidateRowArgsCommon) => AnyObject | Promise<AnyObject>;
+export type PostValidateRowBasic = (args: ValidateRowArgs) => void | Promise<void>;
+export type ValidateRowBasic = (args: ValidateRowArgs) => AnyObject | Promise<AnyObject>;
 export type ValidateUpdateRow<R extends AnyObject = AnyObject, S extends DBSchema | void = void> = (
   args: ValidateUpdateRowArgs<Partial<R>, FullFilter<R, S>, DBOFullyTyped<S>>,
 ) => Partial<R> | Promise<Partial<R>>;

package/lib/TableConfig/TableConfig.ts

@@ -3,6 +3,7 @@ import type {
   ALLOWED_EXTENSION,
   AnyObject,
   ColumnInfo,
+  DBSchema,
   JSONB,
   StrictUnion,
   TableInfo,
@@ -12,7 +13,11 @@ import type { JoinInfo, LocalParams } from "../DboBuilder/DboBuilder";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { uploadFile } from "../DboBuilder/uploadFile";
 import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
-import type { InsertRule, ValidateRowArgsCommon } from "../PublishParser/PublishParser";
+import type {
+  InsertRule,
+  ValidateRowArgsCommon,
+  ValidateRowsArgsCommon,
+} from "../PublishParser/PublishParser";
 import { initTableConfig } from "./initTableConfig";
 
 type ColExtraInfo = {
@@ -41,7 +46,7 @@ export const parseI18N = <Config extends LangToTranslation>(params: {
   return defaultValue;
 };
 
-type BaseTableDefinition = {
+type BaseTableDefinition<R = AnyObject, DBX = DBHandlerServer> = {
   info?: {
     label?: string | LangToTranslation;
   };
@@ -55,6 +60,24 @@ type BaseTableDefinition = {
     getPreInsertRow?: (
       args: GetPreInsertRowArgs,
     ) => Promise<{ row: AnyObject; onInserted: Promise<void> }>;
+    afterEach?: {
+      commands: Partial<Record<"insert" | "update", 1>>;
+      changedFields?: string[];
+      validate: <R = AnyObject, DBX = DBHandlerServer>(
+        params: ValidateRowArgsCommon<R, DBX> & {
+          localParams: undefined | LocalParams;
+        },
+      ) => Promise<void>;
+    }[];
+    afterAll?: {
+      commands: Partial<Record<"insert" | "update", 1>>;
+      changedFields?: string[];
+      validate: <R = AnyObject, DBX = DBHandlerServer>(
+        params: ValidateRowsArgsCommon<R, DBX> & {
+          localParams: undefined | LocalParams;
+        },
+      ) => Promise<void>;
+    }[];
   };
   triggers?: {
     [triggerName: string]: {
@@ -89,7 +112,7 @@ type BaseTableDefinition = {
   };
 };
 
-type LookupTableDefinition<LANG_IDS> = {
+type LookupTableDefinition<LANG_IDS> = BaseTableDefinition & {
   isLookupTable: {
     values: {
       [id_value: string]:
@@ -230,7 +253,11 @@ type ConstraintType = "PRIMARY KEY" | "UNIQUE" | "CHECK" | "FOREIGN KEY";
  * Each column definition cannot reference to tables that appear later in the table definition.
  * These references should be specified in constraints property
  */
-export type TableDefinition<LANG_IDS> = {
+export type TableDefinition<
+  LANG_IDS = { en: 1 },
+  R = AnyObject,
+  DBX = DBHandlerServer,
+> = BaseTableDefinition<R, DBX> & {
   onMount?: (params: {
     dbo: DBHandlerServer;
     _db: DB;
@@ -318,18 +345,20 @@ export type TableDefinition<LANG_IDS> = {
 };
 
 type GetPreInsertRowArgs = Omit<ValidateRowArgsCommon, "localParams"> & {
-  // preValidate: InsertRule["preValidate"];
   validate: InsertRule["validate"];
   localParams: LocalParams | undefined;
 };
 
-/**
- * Helper utility to create lookup tables for TEXT columns
- */
-export type TableConfig<LANG_IDS = { en: 1 }> = {
-  [table_name: string]: BaseTableDefinition &
-    (TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>);
-};
+export type TableConfig<LANG_IDS = { en: 1 }, S = void, DBX = DBHandlerServer> =
+  S extends DBSchema ?
+    {
+      [TableName in keyof S]:
+        | TableDefinition<LANG_IDS, S[TableName]["columns"], DBX>
+        | LookupTableDefinition<LANG_IDS>;
+    }
+  : {
+      [table_name: string]: TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>;
+    };
 
 /**
  * Will be run between initSQL and fileTable

package/package.json

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