prostgles-server 4.2.605 → 4.2.607

package/lib/DboBuilder/DboBuilder.ts

@@ -250,7 +250,7 @@ export class DboBuilder {
       this.checkingCanSubscribe = false;
     }
     const start = Date.now();
-    const tablesOrViewsReq = await getTablesForSchemaPostgresSQL(this, {
+    const tablesOrViewsReq = await getTablesForSchemaPostgresSQL({ db: this.prostgles.dbForSchema! }, {
       schemaFilter: this.prostgles.opts.schemaFilter,
     });
     await this.prostgles.opts.onLog?.({
@@ -262,7 +262,7 @@ export class DboBuilder {
     const tablesOrViews = tablesOrViewsReq.result;
     this.tablesOrViews = tablesOrViews;
 
-    this.constraints = await getConstraints(this.db, this.prostgles.opts.schemaFilter);
+    this.constraints = await getConstraints(this.prostgles.dbForSchema!, this.prostgles.opts.schemaFilter);
     await this.prepareShortestJoinPaths();
 
     this.dbo = {};

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -1,6 +1,8 @@
 import { type TableInfo as TInfo } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { LocalParams } from "../DboBuilder";
+import { getRawInfo } from "./getRawInfo";
+import { getRawColumns } from "../getColumns";
 import type { ViewHandler } from "./ViewHandler";
 
 export async function getInfo(
@@ -11,80 +13,25 @@ export async function getInfo(
   tableRules?: ParsedTableRule,
   localParams?: LocalParams,
 ): Promise<TInfo> {
-  const validatedTableRules = this.getValidatedRules(tableRules, localParams);
-
-  const fileTableName = this.dboBuilder.prostgles.opts.fileTable?.tableName;
-
+  const tableInfo = getRawInfo.call(this, lang, tableRules, localParams);
   await this._log({
     command: "getInfo",
     localParams,
     data: { lang },
     duration: 0,
   });
-  const allowedFieldsToSelect = this.parseFieldFilter(tableRules?.select?.fields);
-  const { requiredNestedInserts, allowedNestedInserts } = tableRules?.insert ?? {};
-  const label = this.dboBuilder.prostgles.tableConfigurator?.getTableLabel({
-    tableName: this.name,
-    lang,
-  });
-  const tableInfo: TInfo = {
-    oid: this.tableOrViewInfo.oid,
-    comment: this.tableOrViewInfo.comment,
-    qualifiedNameParts: this.tableOrViewInfo.qualifiedNameParts,
-    label,
-    isFileTable:
-      !this.is_media ? undefined : (
-        {
-          allowedNestedInserts,
-        }
-      ),
-    isView: this.isView,
-    hasFiles: Boolean(
-      !this.is_media &&
-      fileTableName &&
-      this.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
-    ),
-    fileTableName,
-    dynamicRules: {
-      update: Boolean(tableRules?.update?.dynamicFields?.length),
-    },
-    /**
-     * Only show column groups that are fully allowed to be selected by the user
-     */
-    uniqueColumnGroups: this.tableOrViewInfo.uniqueColumnGroups?.filter(
-      (g) => !localParams || g.every((c) => allowedFieldsToSelect.includes(c)),
-    ),
-    publishInfo: {
-      select: validatedTableRules.select && {
-        disabledMethods: validatedTableRules.select.disableMethods,
-        syncConfig: this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(this.name),
-      },
-      insert: validatedTableRules.insert && {
-        requiredNestedInserts,
-        allowedNestedInserts: allowedNestedInserts?.map((t) => t.table),
-      },
-      update: validatedTableRules.update && {
-        disabledMethods: tableRules?.update?.disableMethods,
-      },
-      delete: validatedTableRules.delete && {},
-    },
-  };
-
   const modifyClientSchema = this.dboBuilder.prostgles.opts.modifyClientSchema;
-  if (!modifyClientSchema) {
-    return tableInfo;
-  }
+  if (!modifyClientSchema) return tableInfo;
 
   const modifiedTableSchema = await modifyClientSchema(
     {
       name: this.name,
       ...tableInfo,
-      columns: [],
+      columns: await getRawColumns.call(this, lang, undefined, tableRules, localParams),
     },
     this.config,
     localParams?.isRemoteRequest?.clientInfo,
   );
-
   const { columns, name, ...rest } = modifiedTableSchema;
   return rest;
 }

package/lib/DboBuilder/ViewHandler/getRawInfo.ts

@@ -0,0 +1,65 @@
+import { type TableInfo as TInfo } from "prostgles-types/dist";
+import type { ParsedTableRule } from "../../PublishParser/PublishParser";
+import type { LocalParams } from "../DboBuilder";
+import type { ViewHandler } from "./ViewHandler";
+
+/** Table metadata before client schema customisation. */
+export function getRawInfo(
+  this: ViewHandler,
+  lang?: string,
+  tableRules?: ParsedTableRule,
+  localParams?: LocalParams,
+): TInfo {
+  const validatedTableRules = this.getValidatedRules(tableRules, localParams);
+  const fileTableName = this.dboBuilder.prostgles.opts.fileTable?.tableName;
+  const allowedFieldsToSelect = this.parseFieldFilter(tableRules?.select?.fields);
+  const { requiredNestedInserts, allowedNestedInserts } = tableRules?.insert ?? {};
+  const label = this.dboBuilder.prostgles.tableConfigurator?.getTableLabel({
+    tableName: this.name,
+    lang,
+  });
+  const tableInfo: TInfo = {
+    oid: this.tableOrViewInfo.oid,
+    comment: this.tableOrViewInfo.comment,
+    qualifiedNameParts: this.tableOrViewInfo.qualifiedNameParts,
+    label,
+    isFileTable:
+      !this.is_media ? undefined : (
+        {
+          allowedNestedInserts,
+        }
+      ),
+    isView: this.isView,
+    hasFiles: Boolean(
+      !this.is_media &&
+      fileTableName &&
+      this.columns.some((c) => c.references?.some((r) => r.ftable === fileTableName)),
+    ),
+    fileTableName,
+    dynamicRules: {
+      update: Boolean(tableRules?.update?.dynamicFields?.length),
+    },
+    /**
+     * Only show column groups that are fully allowed to be selected by the user
+     */
+    uniqueColumnGroups: this.tableOrViewInfo.uniqueColumnGroups?.filter(
+      (g) => !localParams || g.every((c) => allowedFieldsToSelect.includes(c)),
+    ),
+    publishInfo: {
+      select: validatedTableRules.select && {
+        disabledMethods: validatedTableRules.select.disableMethods,
+        syncConfig: this.dboBuilder.prostgles.tableConfigurator?.getTableSyncConfig(this.name),
+      },
+      insert: validatedTableRules.insert && {
+        requiredNestedInserts,
+        allowedNestedInserts: allowedNestedInserts?.map((t) => t.table),
+      },
+      update: validatedTableRules.update && {
+        disabledMethods: tableRules?.update?.disableMethods,
+      },
+      delete: validatedTableRules.delete && {},
+    },
+  };
+
+  return tableInfo;
+}

package/lib/DboBuilder/getColumns.ts

@@ -5,6 +5,7 @@ import type { LocalParams } from "./DboBuilder";
 import { getErrorAsObject, getSerializedClientErrorFromPGError } from "./DboBuilder";
 import type { TableHandler } from "./TableHandler/TableHandler";
 import type { ViewHandler } from "./ViewHandler/ViewHandler";
+import { getRawInfo } from "./ViewHandler/getRawInfo";
 
 export const isTableHandler = (v: any): v is TableHandler => "parseUpdateRules" in v;
 
@@ -18,102 +19,12 @@ export async function getColumns(
 ): Promise<ValidatedColumnInfo[]> {
   const start = Date.now();
   try {
-    const rules = this.getValidatedRules(tableRules, localParams);
-
-    let dynamicUpdateFields = this.column_names;
-
-    if (params && tableRules && isTableHandler(this)) {
-      if (
-        !isObject(params) ||
-        !isObject(params.filter) ||
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        params.rule !== "update"
-      ) {
-        throw (
-          "params must be { rule: 'update', filter: object } but received: " +
-          JSON.stringify(params)
-        );
-      }
-
-      if (!tableRules.update) {
-        dynamicUpdateFields = [];
-      } else {
-        const { filter } = params;
-        const updateRules = await this.parseUpdateRules(filter, undefined, tableRules, localParams);
-        dynamicUpdateFields = updateRules.fields;
-      }
-    }
-
-    const rawColumns: ValidatedColumnInfo[] = this.columns
-      .filter((c) => {
-        const { insert, select, update } = rules;
-
-        return [insert, select, update]
-          .filter(isDefined)
-          .flatMap((rule) => rule.fields)
-          .includes(c.name);
-      })
-      .map((_c) => {
-        const c = { ..._c };
-
-        const label = capitalizeFirstLetter(c.name, " ");
-
-        const select = !!c.privileges.SELECT;
-        const insert = !!c.privileges.INSERT;
-        const _delete = !!this.tableOrViewInfo.privileges.delete;
-        let update = !!c.privileges.UPDATE;
-
-        const prostgles = this.dboBuilder.prostgles;
-        const fileConfig = getFileColumnInfo({
-          colName: c.name,
-          tableHandler: this,
-        });
-
-        /** Do not allow updates to file table unless it's to delete fields */
-        if (prostgles.opts.fileTable?.tableName === this.name) {
-          update = false;
-        }
-
-        const nonOrderableUD_Types: string[] = [..._PG_geometric, "xml"];
-
-        const result: ValidatedColumnInfo = {
-          ...omitKeys(c, ["privileges"]),
-          label,
-          tsDataType: postgresToTsType(c.udt_name),
-          insert:
-            insert &&
-            !!rules.insert?.fields.includes(c.name) &&
-            tableRules?.insert?.forcedData?.[c.name] === undefined &&
-            c.is_updatable,
-          select: select && !!rules.select?.fields.includes(c.name),
-          orderBy:
-            select &&
-            !!rules.select?.orderByFields.includes(c.name) &&
-            !nonOrderableUD_Types.includes(c.udt_name),
-          filter: !!rules.select?.filterFields.includes(c.name),
-          update:
-            update &&
-            !!rules.update?.fields.includes(c.name) &&
-            tableRules?.update?.forcedData?.[c.name] === undefined &&
-            c.is_updatable &&
-            dynamicUpdateFields.includes(c.name),
-          delete: _delete && !!rules.delete?.filterFields.includes(c.name),
-          ...(prostgles.tableConfigurator?.getColInfo({
-            table: this.name,
-            col: c.name,
-            lang,
-          }) || {}),
-          ...(fileConfig && { file: fileConfig }),
-        };
-
-        return result;
-      })
-      .filter((c) => c.select || c.update || c.delete || c.insert);
+    const rawColumns = await getRawColumns.call(this, lang, params, tableRules, localParams);
 
     const modifiedTableSchema = await this.dboBuilder.prostgles.opts.modifyClientSchema?.(
       {
         name: this.name,
-        ...(await this.getInfo()),
+        ...getRawInfo.call(this, lang, tableRules, localParams),
         columns: rawColumns,
       },
       this.config,
@@ -146,6 +57,108 @@ export async function getColumns(
   }
 }
 
+/** Permission-filtered columns before client schema customisation. */
+export async function getRawColumns(
+  this: ViewHandler,
+  lang?: string,
+  params?: { rule: "update"; filter: AnyObject },
+  tableRules?: ParsedTableRule,
+  localParams?: LocalParams,
+): Promise<ValidatedColumnInfo[]> {
+  const rules = this.getValidatedRules(tableRules, localParams);
+
+  let dynamicUpdateFields = this.column_names;
+
+  if (params && tableRules && isTableHandler(this)) {
+    if (
+      !isObject(params) ||
+      !isObject(params.filter) ||
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      params.rule !== "update"
+    ) {
+      throw (
+        "params must be { rule: 'update', filter: object } but received: " + JSON.stringify(params)
+      );
+    }
+
+    if (!tableRules.update) {
+      dynamicUpdateFields = [];
+    } else {
+      const { filter } = params;
+      const updateRules = await this.parseUpdateRules(filter, undefined, tableRules, localParams);
+      dynamicUpdateFields = updateRules.fields;
+    }
+  }
+
+  const rawColumns: ValidatedColumnInfo[] = this.columns
+    .filter((c) => {
+      const { insert, select, update } = rules;
+
+      return [insert, select, update]
+        .filter(isDefined)
+        .flatMap((rule) => rule.fields)
+        .includes(c.name);
+    })
+    .map((_c) => {
+      const c = { ..._c };
+
+      const label = capitalizeFirstLetter(c.name, " ");
+
+      const select = !!c.privileges.SELECT;
+      const insert = !!c.privileges.INSERT;
+      const _delete = !!this.tableOrViewInfo.privileges.delete;
+      let update = !!c.privileges.UPDATE;
+
+      const prostgles = this.dboBuilder.prostgles;
+      const fileConfig = getFileColumnInfo({
+        colName: c.name,
+        tableHandler: this,
+      });
+
+      /** Do not allow updates to file table unless it's to delete fields */
+      if (prostgles.opts.fileTable?.tableName === this.name) {
+        update = false;
+      }
+
+      const nonOrderableUD_Types: string[] = [..._PG_geometric, "xml"];
+
+      const result: ValidatedColumnInfo = {
+        ...omitKeys(c, ["privileges"]),
+        label,
+        tsDataType: postgresToTsType(c.udt_name),
+        insert:
+          insert &&
+          !!rules.insert?.fields.includes(c.name) &&
+          tableRules?.insert?.forcedData?.[c.name] === undefined &&
+          c.is_updatable,
+        select: select && !!rules.select?.fields.includes(c.name),
+        orderBy:
+          select &&
+          !!rules.select?.orderByFields.includes(c.name) &&
+          !nonOrderableUD_Types.includes(c.udt_name),
+        filter: !!rules.select?.filterFields.includes(c.name),
+        update:
+          update &&
+          !!rules.update?.fields.includes(c.name) &&
+          tableRules?.update?.forcedData?.[c.name] === undefined &&
+          c.is_updatable &&
+          dynamicUpdateFields.includes(c.name),
+        delete: _delete && !!rules.delete?.filterFields.includes(c.name),
+        ...(prostgles.tableConfigurator?.getColInfo({
+          table: this.name,
+          col: c.name,
+          lang,
+        }) || {}),
+        ...(fileConfig && { file: fileConfig }),
+      };
+
+      return result;
+    })
+    .filter((c) => c.select || c.update || c.delete || c.insert);
+
+  return rawColumns;
+}
+
 const capitalizeFirstLetter = (string: string, nonAlphaNumericReplacement = " ") => {
   const str = string.replace(/[\W_]+/g, nonAlphaNumericReplacement);
   return str.charAt(0).toUpperCase() + str.slice(1);

package/lib/DboBuilder/runSql/QueryStreamer.ts

@@ -107,6 +107,7 @@ export class QueryStreamer {
     let streamState: "started" | "ended" | "errored" | undefined;
 
     const startStream = async (client: pg.Client | undefined, query: ClientStreamedRequest) => {
+      await this.dboBuilder.prostgles.schemaReady;
       await this.dboBuilder.cacheDBTypes();
       const socketQuery = this.socketQueries.get(socketId)?.get(id);
       if (!socketQuery) {

package/lib/DboBuilder/schema/getTablesForSchemaPostgresSQL.ts

@@ -25,7 +25,7 @@ export const getSchemaFilter = (schema: ProstglesInitOptions["schemaFilter"] = {
 // TODO: Add a onSocketConnect timeout for this query.
 //  Reason: this query gets blocked by prostgles.app_triggers from PubSubManager.addTrigger in some cases (pg_dump locks that table)
 export async function getTablesForSchemaPostgresSQL(
-  { db, runSQL }: Pick<DboBuilder, "db" | "runSQL">,
+  { db }: Pick<DboBuilder, "db">,
   {
     schemaFilter,
     ddlWithRollback,
@@ -288,7 +288,7 @@ export async function getTablesForSchemaPostgresSQL(
         });
 
         /** Get view reference cols (based on parent table) */
-        const viewReferenceColumns = await getViewReferenceColumns(table, tableSchemaList, runSQL);
+        const viewReferenceColumns = await getViewReferenceColumns(table, tableSchemaList, db);
 
         table.columns = table.columns.map((col) => {
           if (col.has_default) {

package/lib/DboBuilder/schema/getViewReferenceColumns.ts

@@ -1,11 +1,12 @@
-import { isDefined, type SQLResult } from "prostgles-types";
-import type { DboBuilder } from "../DboBuilder";
+import { isDefined } from "prostgles-types";
+import type { DB } from "../../Prostgles";
+import { getDbTypes, getDetailedFieldInfo } from "../runSql/runSqlUtils";
 import type { TableSchema, TableSchemaColumn } from "../DboBuilderTypes";
 
 export const getViewReferenceColumns = async (
   table: TableSchema,
   tableSchemaList: TableSchema[],
-  runSQL: DboBuilder["runSQL"]
+  db: DB
 ) => {
   const viewReferenceColumns: Pick<TableSchemaColumn, "name" | "references">[] = [];
   if (!table.is_view || !table.view_definition) {
@@ -16,12 +17,10 @@ export const getViewReferenceColumns = async (
       table.view_definition.endsWith(";") ?
         table.view_definition.slice(0, -1)
       : table.view_definition;
-    const { fields: viewFieldsWithInfo } = (await runSQL(
+    const { fields } = await db.result(
       `SELECT * FROM \n ( ${view_definition} \n) t LIMIT 0`,
-      {},
-      {},
-      undefined
-    )) as SQLResult<undefined>;
+    );
+    const viewFieldsWithInfo = getDetailedFieldInfo(await getDbTypes(db), fields);
     const viewTables = tableSchemaList.filter((r) =>
       viewFieldsWithInfo.some((f) => f.tableID === r.oid)
     );

package/lib/Prostgles.ts

@@ -63,6 +63,9 @@ import type { getAdminClient } from "./DboBuilder/runSql/getAdminClient";
 import type { TableHandler } from "./DboBuilder/TableHandler/TableHandler";
 import { getFileTableConfig } from "./StorageClient/getFileTableConfig";
 import { dirname } from "path";
+import { getAuditTableConfig, type ParsedAuditConfig } from "./Audit/getAuditTableConfig";
+import { syncTableTriggers } from "./TableConfig/syncTableTriggers";
+import { isManagedTriggerName } from "./TableConfig/managedTriggerNames";
 
 export class Prostgles {
   /**
@@ -106,6 +109,16 @@ export class Prostgles {
 
   keywords = DEFAULT_KEYWORDS;
   loaded = false;
+  /** Only schema setup uses this original connection. Application handlers use db. */
+  dbForSchema?: DB;
+  schemaReady: Promise<void> = Promise.resolve();
+
+  runSchemaQueries = (queries: () => Promise<void>) => {
+    this.schemaReady = this.schemaReady.catch(() => {}).then(queries);
+    void this.schemaReady.catch(() => {});
+    return this.schemaReady;
+  };
+  parsedAuditConfig?: ParsedAuditConfig;
   preparingTableConfig = false;
 
   dbEventsManager?: DBEventsManager;
@@ -116,7 +129,15 @@ export class Prostgles {
   tableConfigurator?: TableConfigurator;
 
   get mergedTableConfig() {
-    return getFileTableConfig(this);
+    for (const [tableName, table] of Object.entries(this.opts.tableConfig ?? {})) {
+      for (const name of Object.keys(table.triggers ?? {})) {
+        if (isManagedTriggerName(name)) {
+          throw new Error(`Trigger ${tableName}.${name} uses a prefix reserved for prostgles`);
+        }
+      }
+    }
+    const config = getFileTableConfig(this);
+    return { ...config, tableConfig: getAuditTableConfig(this, config.tableConfig) };
   }
 
   isMedia(tableName: string) {
@@ -148,6 +169,7 @@ export class Prostgles {
       onQuery: 1,
       onConnectionError: 1,
       tableConfig: 1,
+      audit: 1,
       tableHooks: 1,
       tableConfigMigrations: 1,
       onNotice: 1,
@@ -286,10 +308,18 @@ export class Prostgles {
 
   /** Rebuilds the DBO and replaces the application context. */
   refreshDBO = async () => {
+    this.loaded = false;
     await this.cleanupContext();
-    const dbo = await this.rebuildDBO();
+    await this.runSchemaQueries(async () => {
+      await this.rebuildDBO();
+      if (this.opts.audit || this.parsedAuditConfig) {
+        await syncTableTriggers(this);
+        await this.rebuildDBO();
+      }
+    });
     await this.createContext({ type: "dbo.refresh" });
-    return dbo;
+    this.loaded = true;
+    return this.dbo!;
   };
 
   initRestApi = () => {
@@ -307,7 +337,6 @@ export class Prostgles {
       if (this.tableConfigurator?.initialising) {
         console.error("TableConfigurator WILL deadlock", { reason });
       }
-      await this.tableConfigurator?.destroy();
       this.tableConfigurator = new TableConfigurator(this);
       try {
         const now = Date.now();
@@ -323,7 +352,7 @@ export class Prostgles {
           duration: Date.now() - now,
         });
       } catch (e) {
-        if (this.opts.tableConfigMigrations?.silentFail === false) {
+        if (!this.opts.audit && this.opts.tableConfigMigrations?.silentFail === false) {
           console.error("TableConfigurator silentFail: ", e);
         } else {
           throw e;

package/lib/ProstglesTypes.ts

@@ -14,6 +14,7 @@ import type { StorageClient } from "./StorageClient/StorageClientTypes";
 import type { PGConstraint } from "./TableConfig/fetchTableConstraints";
 import type { TableConfig } from "./TableConfig/TableConfigTypes";
 import type { TableHooks } from "./TableHooks/TableHooks";
+import type { SchemaConfigAudit } from "./Audit/AuditTypes";
 
 import type { PRGLIOSocket } from "./DboBuilder/DboBuilder";
 
@@ -312,6 +313,8 @@ export type ProstglesInitOptions<
    * made to the database schema through SQL queries
    */
   tableConfig?: TableConfig;
+  /** Audit committed row changes after bootstrap, before application callbacks run. */
+  audit?: SchemaConfigAudit<S>;
 
   /**
    * Migration logic used when the new tableConfig version is higher than the one in the database.

package/lib/PubSubManager/getCreatePubSubManagerError.ts

@@ -6,7 +6,7 @@ import type { DboBuilder } from "../DboBuilder/DboBuilder";
 export const getCreatePubSubManagerError = async (
   dboBuilder: DboBuilder
 ): Promise<string | undefined> => {
-  const db = dboBuilder.db;
+  const db = dboBuilder.prostgles.dbForSchema!;
 
   const canExecute = await getCanExecute(db);
   if (!canExecute) return "Cannot run EXECUTE statements on this connection";

package/lib/PubSubManager/init/getPubSubManagerInitQuery.ts

@@ -500,19 +500,19 @@ COMMIT;
 export const getPubSubManagerInitQuery = async function (
   this: DboBuilder,
 ): Promise<string | undefined> {
-  const versionNum = await this.db.one("SELECT current_setting('server_version_num')::int as val");
+  const versionNum = await this.prostgles.dbForSchema!.one("SELECT current_setting('server_version_num')::int as val");
   const initQuery = getInitQuery(this.prostgles.opts.DEBUG_MODE, versionNum.val);
-  const { schema_md5 = "none" } = await this.db.oneOrNone("SELECT md5($1) as schema_md5", [
+  const { schema_md5 = "none" } = await this.prostgles.dbForSchema!.oneOrNone("SELECT md5($1) as schema_md5", [
     initQuery.trim(),
   ]);
   const query = pgp.as.format(initQuery, { schema_md5, version });
-  const existingSchema = await this.db.any(PROSTGLES_SCHEMA_EXISTS_QUERY);
+  const existingSchema = await this.prostgles.dbForSchema!.any(PROSTGLES_SCHEMA_EXISTS_QUERY);
   if (!existingSchema.length) {
     console.log("getPubSubManagerInitQuery: No prostgles.versions table found. Creating...");
     return query;
   }
   const { data: existingSchemaVersions } = await tryCatchV2(async () => {
-    const existingSchemaVersions = await this.db.any(PROSTGLES_SCHEMA_VERSION_OK_QUERY, {
+    const existingSchemaVersions = await this.prostgles.dbForSchema!.any(PROSTGLES_SCHEMA_VERSION_OK_QUERY, {
       schema_md5,
       version,
     });

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -1,3 +1,4 @@
+import { isAuditTable } from "../Audit/getAuditTableConfig";
 import { getObjectEntries, isObject } from "prostgles-types";
 import type { AuthResultWithSID } from "../Auth/AuthTypes";
 import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
@@ -42,7 +43,7 @@ export async function getTableRulesWithoutFileTable(
 
   const isStarOrTrue = (value: any): value is "*" | true => value === "*" || value === true;
   const { privileges } = tableHandler.tableOrViewInfo;
-  const tableRulesObject =
+  const rawTableRulesObject =
     isStarOrTrue(rawTableRule) ?
       {
         select: privileges.select ? TABLE_RULE_NO_LIMITS.select : undefined,
@@ -52,6 +53,10 @@ export async function getTableRulesWithoutFileTable(
       }
     : rawTableRule;
 
+  const tableRulesObject = isAuditTable(this.prostgles, tableName)
+    ? { select: rawTableRulesObject.select, insert: undefined, update: undefined, delete: undefined }
+    : rawTableRulesObject;
+
   const selectRule =
     !tableRulesObject.select ? undefined
     : isStarOrTrue(tableRulesObject.select) ? TABLE_RULE_NO_LIMITS.select

package/lib/TableConfig/TableConfigTypes.ts

@@ -31,7 +31,7 @@ type BaseTableDefinition = {
        * Use "before" when you need to change the data before the action
        */
       type: "before" | "after" | "instead of";
-      actions: ("insert" | "update" | "delete")[];
+      actions: ("insert" | "update" | "delete" | "truncate")[];
       forEach: "statement" | "row";
       /**
        * @example

package/lib/TableConfig/TableConfigurator.ts

@@ -23,8 +23,8 @@ export class TableConfigurator {
     return this.prostgles.dbo;
   }
   get db(): DB {
-    if (!this.prostgles.db) throw "this.prostgles.db missing";
-    return this.prostgles.db;
+    if (!this.prostgles.dbForSchema) throw "Schema database connection missing";
+    return this.prostgles.dbForSchema;
   }
   prostgles: Prostgles;
 

package/lib/TableConfig/getTableConfigSchemaQueries.ts

@@ -1,3 +1,4 @@
+import { getManagedTriggerName } from "./managedTriggerNames";
 import { as } from "pg-promise";
 import { isDefined } from "prostgles-types";
 import type { DB } from "../initProstgles";
@@ -226,14 +227,14 @@ const getTriggerQueries = (
     ];
 
     trigger.actions.forEach((action) => {
-      const triggerActionName = triggerFuncName + "_" + action;
+      const triggerActionName = getManagedTriggerName(triggerFuncName, action);
 
       const triggerActionNameParsed = asName(triggerActionName);
 
       const newTableName = action !== "delete" ? "NEW TABLE AS new_table" : "";
       const oldTableName = action !== "insert" ? "OLD TABLE AS old_table" : "";
       const transitionTables =
-        trigger.forEach === "row" ? "" : `REFERENCING ${newTableName} ${oldTableName}`;
+        trigger.forEach === "row" || trigger.type !== "after" || action === "truncate" ? "" : `REFERENCING ${newTableName} ${oldTableName}`;
       queries.push(`
           CREATE TRIGGER ${triggerActionNameParsed}
           ${trigger.type} ${action} ON ${tableName}