prostgles-server 4.2.582 → 4.2.584

package/lib/StorageClient/getFileTableConfig.ts

@@ -1,11 +1,12 @@
 import { omitKeys } from "prostgles-types";
+import { onDeleteFromFileTable } from "../DboBuilder/TableHandler/onDeleteFromFileTable";
 import { updateFile } from "../DboBuilder/TableHandler/updateFile";
 import { assertFileObjectValid, uploadFile } from "../DboBuilder/TableHandler/uploadFile";
 import type { Prostgles } from "../Prostgles";
+import type { BeforeEachTsTrigger } from "../PublishParser/publishTypesAndUtils";
 import type { TableConfig } from "../TableConfig/TableConfigTypes";
+import type { TableHooks } from "../TableHooks/TableHooks";
 import { setupFileServeHandler } from "./setupFileServeHandler";
-import { onDeleteFromFileTable } from "../DboBuilder/TableHandler/onDeleteFromFileTable";
-import type { BeforeEachTsTrigger } from "../PublishParser/publishTypesAndUtils";
 
 const FILE_TABLE_COLUMN_DEFINITIONS = {
   id: `UUID PRIMARY KEY DEFAULT gen_random_uuid()`,
@@ -41,10 +42,12 @@ export type FileTableRow = {
   : string | null;
 };
 
-export const getFileTableConfig = (prg: Prostgles): TableConfig | undefined => {
-  const { fileTable, tableConfig } = prg.opts;
+export const getFileTableConfig = (
+  prg: Prostgles,
+): { tableConfig: TableConfig | undefined; tableHooks: TableHooks | undefined } => {
+  const { fileTable, tableConfig, tableHooks } = prg.opts;
   if (!fileTable) {
-    return tableConfig;
+    return { tableConfig, tableHooks };
   }
 
   const { expressApp } = fileTable;
@@ -76,7 +79,7 @@ export const getFileTableConfig = (prg: Prostgles): TableConfig | undefined => {
     }
   }
 
-  return {
+  const mergedTableConfig: TableConfig = {
     [fileTableName]: {
       ...userFileTableConfig,
       columns: {
@@ -94,71 +97,75 @@ export const getFileTableConfig = (prg: Prostgles): TableConfig | undefined => {
           onUnmount: destroy,
         };
       },
-      hooks: {
-        ...userFileTableConfig?.hooks,
-        beforeEach: [
-          {
-            commands: {
-              insert: 1,
-              update: 1,
-            },
-            validate: async ({ data: insertData, localParams, command, filter }) => {
-              const tableHandler = prg.dboBuilder.dboMap.get(fileTableName);
-              if (!tableHandler) throw "Storage tableHandler not found";
-              assertFileObjectValid(insertData);
+    },
+    ...omitKeys(tableConfig ?? {}, [fileTableName]),
+  };
 
-              const {
-                data: dataBlob,
-                original_name,
-                id,
-                original_last_modified = null,
-              } = insertData;
-              const data = dataBlob as unknown as Buffer;
-              if (command === "update") {
-                const { newData } = await updateFile(tableHandler, fileTable, {
-                  filter: filter ?? {},
-                  localParams,
-                  data,
-                  original_name,
-                  original_last_modified,
-                });
-                return {
-                  row: newData,
-                  hookContext: {
-                    data,
-                  },
-                };
-              }
+  const userFileTableHooks = tableHooks?.[fileTableName];
+  const mergedTableHooks: TableHooks = {
+    [fileTableName]: {
+      ...userFileTableHooks,
+      beforeEach: [
+        {
+          commands: {
+            insert: 1,
+            update: 1,
+          },
+          validate: async ({ data: insertData, localParams, command, filter }) => {
+            const tableHandler = prg.dboBuilder.dboMap.get(fileTableName);
+            if (!tableHandler) throw "Storage tableHandler not found";
+            assertFileObjectValid(insertData);
 
-              const media = await uploadFile(fileTable, {
+            const { data: dataBlob, original_name, id, original_last_modified = null } = insertData;
+            const data = dataBlob as unknown as Buffer;
+            if (command === "update") {
+              const { newData } = await updateFile(tableHandler, fileTable, {
+                filter: filter ?? {},
+                localParams,
                 data,
                 original_name,
-                localParams,
-                mediaId: id,
                 original_last_modified,
               });
-
               return {
-                row: media,
+                row: newData,
                 hookContext: {
                   data,
                 },
               };
-            },
-          } satisfies BeforeEachTsTrigger<FileTableRow, {}>,
-          ...(userFileTableConfig?.hooks?.beforeEach || []),
-        ],
-        onInsteadOfDelete: async ({ dbx, tx, returningQuery, isOneOrNone, filterOpts }) => {
-          return onDeleteFromFileTable(fileTable, {
-            dbTX: dbx,
-            t: tx,
-            returningQuery,
-            isOneOrNone,
-            filterOpts,
-          });
-        },
+            }
+
+            const media = await uploadFile(fileTable, {
+              data,
+              original_name,
+              localParams,
+              mediaId: id,
+              original_last_modified,
+            });
+
+            return {
+              row: media,
+              hookContext: {
+                data,
+              },
+            };
+          },
+        } satisfies BeforeEachTsTrigger<FileTableRow, {}>,
+        ...(userFileTableHooks?.beforeEach || []),
+      ],
+      onInsteadOfDelete: async ({ dbx, tx, returningQuery, isOneOrNone, filterOpts }) => {
+        return onDeleteFromFileTable(fileTable, {
+          dbTX: dbx,
+          t: tx,
+          returningQuery,
+          isOneOrNone,
+          filterOpts,
+        });
       },
     },
-    ...omitKeys(tableConfig ?? {}, [fileTableName]),
+  };
+
+  return {
+    tableConfig: mergedTableConfig,
+    tableHooks: mergedTableHooks,
   };
 };

package/lib/TableConfig/TableConfigTypes.ts

@@ -28,36 +28,14 @@ export type ColExtraInfo = {
 
 export type LangToTranslation = Record<string, string>;
 
-type BaseTableDefinition<R = AnyObject, DBX = DBHandlerServer> = {
+type BaseTableDefinition = {
   info?: {
     label?: string | LangToTranslation;
   };
   dropIfExistsCascade?: boolean;
   dropIfExists?: boolean;
   syncConfig?: SyncConfig;
-  hooks?: {
-    /**
-     * Hook used to run custom logic before inserting a row.
-     * 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>[];
-    onInsteadOfDelete?: (args: {
-      dbx: DBX;
-      tx: pgPromise.ITask<{}>;
-      returningQuery: string;
-      isOneOrNone: boolean;
-      queryType: "any" | "none";
-      filterOpts: {
-        where: string;
-        filter: AnyObject;
-      };
-    }) => Promise<AnyObject[]>;
-  };
+
   triggers?: {
     [triggerName: string]: {
       /**
@@ -232,11 +210,7 @@ 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 = { en: 1 },
-  R = AnyObject,
-  DBX = DBHandlerServer,
-> = BaseTableDefinition<R, DBX> & {
+export type TableDefinition<LANG_IDS = { en: 1 }> = BaseTableDefinition & {
   onMount?: (params: {
     dbo: DBHandlerServer;
     _db: DB;
@@ -323,18 +297,6 @@ export type TableDefinition<
   };
 };
 
-type GetPreInsertRowArgs = Omit<ValidateRowArgsCommon, "localParams"> & {
-  validate: InsertRule["validate"];
-  localParams: LocalParams | undefined;
+export type TableConfig<LANG_IDS = { en: 1 }> = {
+  [table_name: string]: TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>;
 };
-
-export type TableConfig<LANG_IDS = { en: 1 }, S = void> =
-  S extends DBSchema ?
-    Partial<{
-      [TableName in keyof S]:
-        | TableDefinition<LANG_IDS, S[TableName]["columns"], DBOFullyTyped<S>>
-        | LookupTableDefinition<LANG_IDS>;
-    }>
-  : {
-      [table_name: string]: TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>;
-    };

package/lib/TableConfig/TableConfigurator.ts

@@ -16,7 +16,7 @@ export class TableConfigurator {
   instanceId = Date.now() + Math.random();
 
   get config() {
-    return this.prostgles.mergedTableConfig ?? {};
+    return this.prostgles.mergedTableConfig.tableConfig ?? {};
   }
   get dbo(): DBHandlerServer {
     if (!this.prostgles.dbo) throw "this.prostgles.dbo missing";

package/lib/TableHooks/TableHooks.ts

@@ -0,0 +1,48 @@
+import type pgPromise from "pg-promise";
+import type { AnyObject, DBSchema } from "prostgles-types";
+
+import type { DbTxTableHandlers, LocalParams } from "../DboBuilder/DboBuilderTypes";
+import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type {
+  AfterAllTsTrigger,
+  AfterEachTsTrigger,
+  BeforeEachTsTrigger,
+  InsertRule,
+  ValidateRowArgsCommon,
+} from "../PublishParser/PublishParser";
+
+export type TableHooks<S = void> =
+  S extends DBSchema ?
+    Partial<{
+      [tableName in keyof S]: TableHooksDefinition<S[tableName]["columns"], DBOFullyTyped<S>>;
+    }>
+  : Record<string, TableHooksDefinition>;
+
+export type TableHooksDefinition<R = AnyObject, DBX = DbTxTableHandlers> = {
+  /**
+   * Hook used to run custom logic before inserting a row.
+   * The returned row must satisfy the table schema.
+   */
+  getPreInsertRow?: (
+    args: PreInsertRowArgs,
+  ) => Promise<{ row: AnyObject; onInserted: Promise<void> }>;
+  beforeEach?: BeforeEachTsTrigger<R, DBX>[];
+  afterEach?: AfterEachTsTrigger<R, DBX>[];
+  afterAll?: AfterAllTsTrigger<R, DBX>[];
+  onInsteadOfDelete?: (args: {
+    dbx: DBX;
+    tx: pgPromise.ITask<{}>;
+    returningQuery: string;
+    isOneOrNone: boolean;
+    queryType: "any" | "none";
+    filterOpts: {
+      where: string;
+      filter: AnyObject;
+    };
+  }) => Promise<AnyObject[] | undefined>;
+};
+
+type PreInsertRowArgs = Omit<ValidateRowArgsCommon, "localParams"> & {
+  validate: InsertRule["validate"];
+  localParams: LocalParams | undefined;
+};

package/lib/index.ts

@@ -20,6 +20,7 @@ export type { StorageClient as CloudClient } from "./StorageClient/StorageClient
 export * from "./StorageClient/getLocalStorageClient";
 export type { DB } from "./initProstgles";
 export type * from "./TableConfig/TableConfigTypes";
+export type * from "./TableHooks/TableHooks";
 export * from "./Auth/utils/upsertNamedExpressMiddleware";
 export type { RequestWithUser } from "./Auth/middleware/userContextMiddleware";
 export default prostgles;

package/lib/updateConfiguration.ts

@@ -29,7 +29,10 @@ export const updateConfiguration = async <DBSchema, UserSchema extends SessionUs
     prgl.initRestApi();
   }
   if (includes(optionsThatChanged, "tableConfig")) {
-    await prgl.initTableConfig({ type: "prgl.update", newOpts });
+    await prgl.initTableConfig({
+      type: "prgl.update",
+      newOpts: newOpts,
+    });
   }
   if (includes(optionsThatChanged, "schema")) {
     await prgl.refreshDBO();
@@ -61,7 +64,10 @@ export const updateConfiguration = async <DBSchema, UserSchema extends SessionUs
   ) {
     prgl.setupSocketIO();
   } else {
-    await prgl.init(onReady, { type: "prgl.update", newOpts });
+    await prgl.init(onReady, {
+      type: "prgl.update",
+      newOpts: newOpts,
+    });
   }
 };
 

package/package.json

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