prostgles-server 4.2.606 → 4.2.608

package/lib/Audit/AuditTable.ts

@@ -0,0 +1,20 @@
+import type { TableRowFromColumnDefinitions } from "../TableConfig/TableRowFromColumnDefinitions";
+
+export const AUDIT_TABLE_COLUMN_DEFINITIONS = {
+  id: "BIGSERIAL PRIMARY KEY",
+  created_at: "TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()",
+  schema_name: "TEXT NOT NULL",
+  table_name: "TEXT NOT NULL",
+  entity_type: "TEXT NOT NULL",
+  operation: { enum: ["INSERT", "UPDATE", "DELETE"] },
+  old_id: "JSONB",
+  new_id: "JSONB",
+  old_row: "JSONB",
+  new_row: "JSONB",
+  actor: "JSONB",
+} as const;
+
+export type AuditTableRow = TableRowFromColumnDefinitions<typeof AUDIT_TABLE_COLUMN_DEFINITIONS>;
+export const AUDIT_TABLE_COLUMNS = Object.keys(
+  AUDIT_TABLE_COLUMN_DEFINITIONS,
+) as (keyof AuditTableRow)[];

package/lib/Audit/AuditTypes.ts

@@ -0,0 +1,35 @@
+export type SchemaConfigTableName<S> = [S] extends [void]
+  ? string
+  : Extract<keyof S, string>;
+export type SchemaConfigColumnName<S, T extends SchemaConfigTableName<S>> = [
+  S,
+] extends [void]
+  ? string
+  : T extends keyof S
+    ? S[T] extends { columns: infer C }
+      ? Extract<keyof C, string>
+      : never
+    : never;
+
+export type SchemaConfigAuditTableOptions<
+  S,
+  T extends SchemaConfigTableName<S>,
+> = {
+  entityType?: string;
+  /** Defaults to all primary-key columns. Required for tables without a primary key. */
+  idColumns?: readonly SchemaConfigColumnName<S, T>[];
+  excludeColumns?: readonly SchemaConfigColumnName<S, T>[];
+};
+export type SchemaConfigAuditIncludedTables<S> = {
+  [T in SchemaConfigTableName<S>]?: 1 | SchemaConfigAuditTableOptions<S, T>;
+};
+export type SchemaConfigAuditExcludedTables<S> = {
+  [T in SchemaConfigTableName<S>]?: 0;
+};
+export type SchemaConfigAudit<S = void> = {
+  /** Managed append-only table. Uses the same table-name handling as tableConfig. */
+  tableName: string;
+  /** Omitted/empty means all eligible tables in schemaFilter. Cannot mix enabled and disabled entries. */
+  tables?:
+    SchemaConfigAuditIncludedTables<S> | SchemaConfigAuditExcludedTables<S>;
+};

package/lib/Audit/getAuditTableConfig.ts

@@ -0,0 +1,56 @@
+import { md5 } from "prostgles-types/dist/md5";
+import type { Prostgles } from "../Prostgles";
+import type { TableConfig, TableDefinition } from "../TableConfig/TableConfigTypes";
+
+import { AUDIT_TABLE_COLUMN_DEFINITIONS } from "./AuditTable";
+import {
+  AUDIT_HISTORY_PROTECTION_PREFIX,
+  AUDIT_TRUNCATE_PROTECTION_PREFIX,
+  AUDIT_WRITER_PREFIX,
+} from "../TableConfig/managedTriggerNames";
+
+export function getAuditProtection(
+  tableName: string,
+  actions: NonNullable<TableDefinition["triggers"]>[string]["actions"],
+): NonNullable<TableDefinition["triggers"]> {
+  return {
+    [(actions.includes("update") ?
+      AUDIT_HISTORY_PROTECTION_PREFIX
+    : AUDIT_TRUNCATE_PROTECTION_PREFIX) + md5(tableName)]: {
+      type: "before",
+      actions,
+      forEach: "statement",
+      query:
+        "BEGIN RAISE EXCEPTION 'Audit protection: % is not allowed on %.%', TG_OP, TG_TABLE_SCHEMA, TG_TABLE_NAME; END;",
+    },
+  };
+}
+
+/** Adds audit definitions to the same config used for file tables and application tables. */
+export const getAuditTableConfig = (
+  prgl: Prostgles,
+  tableConfig: TableConfig | undefined,
+): TableConfig | undefined => {
+  const { audit } = prgl.opts;
+  if (!audit) return tableConfig;
+
+  const { tableName } = audit;
+  if (!tableName) throw new Error("audit.tableName is required");
+  if (tableConfig?.[tableName]) {
+    throw new Error("The audit table cannot also be defined in tableConfig");
+  }
+  return {
+    [tableName]: {
+      columns: AUDIT_TABLE_COLUMN_DEFINITIONS,
+      triggers: getAuditProtection(tableName, ["update", "delete", "truncate"]),
+    },
+    ...tableConfig,
+  };
+};
+
+export function isAuditTable(prgl: Prostgles, tableName: string): boolean {
+  return prgl.opts.audit?.tableName === tableName;
+}
+
+export const getAuditWriterName = (auditTable: string, sourceTable: string) =>
+  AUDIT_WRITER_PREFIX + md5(JSON.stringify([auditTable, sourceTable]));

package/lib/Audit/parseAuditConfig.ts

@@ -0,0 +1,101 @@
+import { as } from "pg-promise";
+import { asName, getEntries } from "prostgles-types";
+import type { Prostgles } from "../Prostgles";
+import type { TableConfig } from "../TableConfig/TableConfigTypes";
+import { isArray } from "../utils/utils";
+import { getAuditProtection, getAuditWriterName } from "./getAuditTableConfig";
+
+/**
+ * Resolve column defaults against the completed schema; generate tableConfig entries only.
+ * */
+export const parseAuditConfig = (prgl: Prostgles): TableConfig | undefined => {
+  const { audit } = prgl.opts;
+  if (!audit) return undefined;
+
+  const tables = prgl.dboBuilder.tables;
+  if (!tables.some((t) => t.name === audit.tableName)) {
+    throw new Error(`Audit table name must exactly match a schema table name: ${audit.tableName}`);
+  }
+  const result: TableConfig = {};
+
+  const entries = getEntries(audit.tables ?? {}).filter(([, value]) => value !== undefined);
+  const exclusion = entries.some(([, value]) => value === 0);
+  if (exclusion && entries.some(([, value]) => value !== 0)) {
+    throw new Error("audit.tables cannot mix enabled and disabled entries");
+  }
+  for (const [name, value] of entries) {
+    if (!tables.some((t) => t.name === name)) throw new Error(`Unknown audit table: ${name}`);
+    if (value !== 0 && value !== 1 && (!value || typeof value !== "object" || Array.isArray(value)))
+      throw new Error(`Invalid audit options for ${name}`);
+  }
+
+  for (const table of tables) {
+    const entry = entries.find(([name]) => name === table.name);
+    if (entries.length && (exclusion ? entry?.[1] === 0 : !entry)) continue;
+
+    const isHistory = table.name === audit.tableName;
+    const eligible = !isHistory && !table.is_view && !table.isHyperTable;
+    if (!eligible) {
+      if (entry && entry[1] !== 0) {
+        throw new Error(
+          `Unsupported audit target: ${table.name}`,
+        );
+      }
+      continue;
+    }
+    const options = typeof entry?.[1] === "object" ? entry[1] : {};
+    const ids = options.idColumns ?? table.columns.filter((c) => c.is_pkey).map((c) => c.name);
+    const excluded = options.excludeColumns ?? [];
+    if (!isArray(ids) || !ids.length) {
+      throw new Error(`audit.idColumns is required for ${table.name} without a primary key`);
+    }
+
+    for (const list of [ids, excluded]) {
+      if (
+        new Set(list).size !== list.length ||
+        list.some((c) => !table.columns.some((col) => col.name === c))
+      ) {
+        throw new Error(`Invalid audit columns for ${table.name}`);
+      }
+    }
+    if (ids.some((c) => excluded.includes(c))) {
+      throw new Error(`Audit identity columns cannot be excluded: ${table.name}`);
+    }
+    if (options.entityType !== undefined && !options.entityType) {
+      throw new Error(`Invalid audit entityType for ${table.name}`);
+    }
+    const functionName = getAuditWriterName(audit.tableName, table.name);
+    result[table.name] = {
+      triggers: {
+        ...getAuditProtection(audit.tableName, ["truncate"]),
+        [functionName]: {
+          type: "after",
+          actions: ["insert", "update", "delete"],
+          forEach: "row",
+          query: `DECLARE
+            before_row jsonb; after_row jsonb; before_id jsonb; after_id jsonb;
+            ids text[] := ARRAY[${ids.map((c) => as.text(c)).join(", ")}]::text[];
+            excluded text[] := ARRAY[${excluded.map((c) => as.text(c)).join(", ")}]::text[];
+          BEGIN
+            IF TG_OP <> 'INSERT' THEN
+              before_row := to_jsonb(OLD);
+              SELECT jsonb_object_agg(k, before_row -> k) INTO before_id FROM unnest(ids) k;
+              before_row := before_row - excluded;
+            END IF;
+            IF TG_OP <> 'DELETE' THEN
+              after_row := to_jsonb(NEW);
+              SELECT jsonb_object_agg(k, after_row -> k) INTO after_id FROM unnest(ids) k;
+              after_row := after_row - excluded;
+            END IF;
+            IF TG_OP = 'UPDATE' AND before_row IS NOT DISTINCT FROM after_row THEN RETURN NULL; END IF;
+            INSERT INTO ${asName(audit.tableName)} (schema_name, table_name, entity_type, operation, old_id, new_id, old_row, new_row, actor)
+              VALUES (TG_TABLE_SCHEMA, TG_TABLE_NAME, ${as.text(options.entityType ?? table.name)}, TG_OP, before_id, after_id, before_row, after_row,
+                nullif(current_setting('prostgles.user', true), '')::jsonb);
+            RETURN NULL;
+          END;`,
+        },
+      },
+    };
+  }
+  return result;
+};

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/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 } from "./Audit/getAuditTableConfig";
+import { syncTableTriggers } from "./TableConfig/syncTableTriggers";
+import { isManagedTriggerName } from "./TableConfig/managedTriggerNames";
 
 export class Prostgles {
   /**
@@ -106,6 +109,15 @@ 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;
+  };
   preparingTableConfig = false;
 
   dbEventsManager?: DBEventsManager;
@@ -116,7 +128,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 +168,7 @@ export class Prostgles {
       onQuery: 1,
       onConnectionError: 1,
       tableConfig: 1,
+      audit: 1,
       tableHooks: 1,
       tableConfigMigrations: 1,
       onNotice: 1,
@@ -286,10 +307,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) {
+        await syncTableTriggers(this);
+        await this.rebuildDBO();
+      }
+    });
     await this.createContext({ type: "dbo.refresh" });
-    return dbo;
+    this.loaded = true;
+    return this.dbo!;
   };
 
   initRestApi = () => {
@@ -307,7 +336,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 +351,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/StorageClient/getFileTableConfig.ts

@@ -5,6 +5,7 @@ import { assertFileObjectValid, uploadFile } from "../DboBuilder/TableHandler/up
 import type { Prostgles } from "../Prostgles";
 import type { BeforeEachTsTrigger } from "../PublishParser/publishTypesAndUtils";
 import type { TableConfig } from "../TableConfig/TableConfigTypes";
+import type { TableRowFromColumnDefinitions } from "../TableConfig/TableRowFromColumnDefinitions";
 import type { TableHooks } from "../TableHooks/TableHooks";
 import { setupFileServeHandler } from "./setupFileServeHandler";
 
@@ -28,19 +29,7 @@ const FILE_TABLE_COLUMN_DEFINITIONS = {
   data: `BYTEA NOT NULL CHECK (data = decode('01', 'hex'))`, // Used as a placeholder to ensure insert types are correct. Actual data is uploaded to storageClient and not stored in the DB
 } as const;
 
-type FileTableColumnDefinitions = typeof FILE_TABLE_COLUMN_DEFINITIONS;
-
-export type FileTableRow = {
-  [K in keyof FileTableColumnDefinitions as K]: FileTableColumnDefinitions[K] extends (
-    `BYTEA NOT NULL${string}`
-  ) ?
-    Buffer
-  : FileTableColumnDefinitions[K] extends (
-    `${string} NOT NULL${string}` | `${string}PRIMARY KEY${string}`
-  ) ?
-    string
-  : string | null;
-};
+export type FileTableRow = TableRowFromColumnDefinitions<typeof FILE_TABLE_COLUMN_DEFINITIONS>;
 
 export const getFileTableConfig = (
   prg: Prostgles,

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/TableRowFromColumnDefinitions.ts

@@ -0,0 +1,19 @@
+/** Row types for the column definitions used by managed tables. */
+export type TableRowFromColumnDefinitions<
+  T extends Record<
+    string,
+    string | { enum: readonly (string | number)[]; nullable?: boolean }
+  >,
+> = {
+  [K in keyof T]: T[K] extends { enum: readonly (infer V)[] }
+    ? V | (T[K] extends { nullable: true } ? null : never)
+    : | (T[K] extends `BYTEA${string}`
+          ? Buffer
+          : T[K] extends `JSONB${string}`
+            ? Record<string, unknown>
+            : string)
+      | (T[K] extends
+          `${string} NOT NULL${string}` | `${string}PRIMARY KEY${string}`
+          ? never
+          : null);
+};

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}