@restura/core 2.0.3 → 2.1.1

package/dist/index.js

@@ -83,16 +83,20 @@ var EventManager = class {
       filter
     });
   }
-  async fireActionFromDbTrigger(sqlMutationData, result) {
+  async fireActionFromDbTrigger(sqlMutationData, result, options) {
+    const handlerErrors = [];
     if (sqlMutationData.mutationType === "INSERT") {
-      await this.fireInsertActions(sqlMutationData, result);
+      await this.fireInsertActions(sqlMutationData, result, handlerErrors);
     } else if (sqlMutationData.mutationType === "UPDATE") {
-      await this.fireUpdateActions(sqlMutationData, result);
+      await this.fireUpdateActions(sqlMutationData, result, handlerErrors);
     } else if (sqlMutationData.mutationType === "DELETE") {
-      await this.fireDeleteActions(sqlMutationData, result);
+      await this.fireDeleteActions(sqlMutationData, result, handlerErrors);
+    }
+    if (options?.rethrowHandlerErrors && handlerErrors.length) {
+      throw handlerErrors[0];
     }
   }
-  async fireInsertActions(data, triggerResult) {
+  async fireInsertActions(data, triggerResult, handlerErrors) {
     await Bluebird.map(
       this.actionHandlers.DATABASE_ROW_INSERT,
       async ({ callback, filter }) => {
@@ -107,12 +111,13 @@ var EventManager = class {
           await callback(insertData, data.queryMetadata);
         } catch (error) {
           logger.error(`Error firing insert action for table ${triggerResult.table}`, error);
+          handlerErrors.push(error);
         }
       },
       { concurrency: 10 }
     );
   }
-  async fireDeleteActions(data, triggerResult) {
+  async fireDeleteActions(data, triggerResult, handlerErrors) {
     await Bluebird.map(
       this.actionHandlers.DATABASE_ROW_DELETE,
       async ({ callback, filter }) => {
@@ -127,12 +132,13 @@ var EventManager = class {
           await callback(deleteData, data.queryMetadata);
         } catch (error) {
           logger.error(`Error firing delete action for table ${triggerResult.table}`, error);
+          handlerErrors.push(error);
         }
       },
       { concurrency: 10 }
     );
   }
-  async fireUpdateActions(data, triggerResult) {
+  async fireUpdateActions(data, triggerResult, handlerErrors) {
     await Bluebird.map(
       this.actionHandlers.DATABASE_COLUMN_UPDATE,
       async ({ callback, filter }) => {
@@ -148,11 +154,53 @@ var EventManager = class {
           await callback(columnChangeData, data.queryMetadata);
         } catch (error) {
           logger.error(`Error firing update action for table ${triggerResult.table}`, error);
+          handlerErrors.push(error);
         }
       },
       { concurrency: 10 }
     );
   }
+  // A handler whose filter doesn't match the schema's notify config silently never fires — surface it at startup
+  validateHandlersAgainstSchema(schema, mode) {
+    if (mode === "off") return;
+    const problems = [];
+    const checkTable = (tableName, handlerKind) => {
+      if (!tableName) return void 0;
+      const table = schema.database.find((item) => item.name === tableName);
+      if (!table) {
+        problems.push(`${handlerKind} handler registered for unknown table "${tableName}"`);
+        return void 0;
+      }
+      if (!table.notify) {
+        problems.push(
+          `${handlerKind} handler registered for table "${tableName}" which has no notify config \u2014 it will never fire`
+        );
+        return void 0;
+      }
+      return table;
+    };
+    this.actionHandlers.DATABASE_ROW_INSERT.forEach(({ filter }) => checkTable(filter?.tableName, "Row-insert"));
+    this.actionHandlers.DATABASE_ROW_DELETE.forEach(({ filter }) => checkTable(filter?.tableName, "Row-delete"));
+    this.actionHandlers.DATABASE_COLUMN_UPDATE.forEach(({ filter }) => {
+      const table = checkTable(filter?.tableName, "Column-change");
+      if (!table || !filter || table.notify === "ALL") return;
+      const notifyColumns = table.notify.map((entry) => entry.replace(/^!/, ""));
+      for (const column of filter.columns) {
+        if (column === "*") continue;
+        if (!notifyColumns.includes(column)) {
+          problems.push(
+            `Column-change handler on "${filter.tableName}" filters column "${column}" which is not in the table's notify list \u2014 it will never fire`
+          );
+        }
+      }
+    });
+    if (!problems.length) return;
+    if (mode === "strict") {
+      throw new Error(`Notify handler validation failed:
+- ${problems.join("\n- ")}`);
+    }
+    problems.forEach((problem) => logger.warn(`Notify handler validation: ${problem}`));
+  }
   hasHandlersForEventType(eventType, filter, triggerResult) {
     if (filter) {
       switch (eventType) {
@@ -211,7 +259,7 @@ var SqlUtils = class _SqlUtils {
     if (type.startsWith("decimal") || type.startsWith("numeric")) return "string";
     if (type.indexOf("int") > -1 || type.startsWith("double") || type.startsWith("float") || type.indexOf("serial") > -1 || type.startsWith("real") || type.startsWith("double precision"))
       return "number";
-    if (type === "json") {
+    if (type === "json" || type === "jsonb") {
       if (!value) return "object";
       return value.split(",").map((val) => {
         return val.replace(/['"]/g, "");
@@ -1812,12 +1860,23 @@ var resturaConfigSchema = z3.object({
   customApiFolderPath: z3.string().default(process.cwd() + customApiFolderPath),
   generatedTypesPath: z3.string().default(process.cwd() + "/src/@types"),
   fileTempCachePath: z3.string().optional(),
-  scratchDatabaseSuffix: z3.string().optional()
+  scratchDatabaseSuffix: z3.string().optional(),
+  eventDelivery: z3.enum(["direct", "outbox"]).default("direct"),
+  eventOutbox: z3.object({
+    channel: z3.string().default("restura_outbox"),
+    pollIntervalMs: z3.number().default(15e3),
+    batchSize: z3.number().default(50),
+    maxAttempts: z3.number().default(5),
+    pruneAfterDays: z3.number().default(7)
+  }).prefault({}),
+  notifyValidation: z3.enum(["off", "warn", "strict"]).default("warn"),
+  queryMetadataKeys: z3.union([z3.literal("ALL"), z3.array(z3.string())]).optional()
 });
 
-// src/restura/sql/PsqlEngine.ts
-import { ObjectUtils as ObjectUtils3 } from "@redskytech/core-utils";
-import pg3 from "pg";
+// src/restura/sql/PsqlConnection.ts
+import crypto from "crypto";
+import { format as sqlFormat } from "sql-formatter";
+import { z as z4 } from "zod";
 
 // src/restura/sql/PsqlUtils.ts
 import format from "pg-format";
@@ -1908,6 +1967,140 @@ function toSqlLiteral(value) {
   return format.literal(value);
 }
 
+// src/restura/sql/PsqlConnection.ts
+var DEFAULT_QUERY_METADATA_KEYS = [
+  "userId",
+  "adminUserId",
+  "isSystemUser",
+  "role",
+  "host",
+  "ipAddress",
+  "storeId",
+  "storeCustomerId",
+  "appTokenId",
+  "requestId"
+];
+var PsqlConnection = class _PsqlConnection {
+  static queryMetadataKeys = DEFAULT_QUERY_METADATA_KEYS;
+  static setQueryMetadataKeys(keys) {
+    _PsqlConnection.queryMetadataKeys = keys;
+  }
+  instanceId;
+  constructor(instanceId) {
+    this.instanceId = instanceId || crypto.randomUUID();
+  }
+  buildQueryMetadata(requesterDetails) {
+    if (_PsqlConnection.queryMetadataKeys === "ALL") {
+      return { connectionInstanceId: this.instanceId, ...requesterDetails };
+    }
+    const meta = { connectionInstanceId: this.instanceId };
+    const details = requesterDetails ?? {};
+    for (const key of _PsqlConnection.queryMetadataKeys) {
+      if (details[key] !== void 0) meta[key] = details[key];
+    }
+    return meta;
+  }
+  async queryOne(query, options, requesterDetails) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const meta = this.buildQueryMetadata(requesterDetails);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
+`;
+    const startTime = process.hrtime();
+    try {
+      const response = await this.query(queryMetadata + formattedQuery, options);
+      if (response.rows.length === 0) throw new RsError("NOT_FOUND", "No results found");
+      else if (response.rows.length > 1) throw new RsError("DUPLICATE", "More than one result found");
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      return response.rows[0];
+    } catch (error) {
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      if (RsError.isRsError(error)) throw error;
+      if (error?.routine === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+  async queryOneSchema(query, params, requesterDetails, zodSchema) {
+    const result = await this.queryOne(query, params, requesterDetails);
+    try {
+      return zodSchema.parse(result);
+    } catch (error) {
+      if (error instanceof z4.ZodError) {
+        logger.error("Invalid data returned from database:");
+        logger.trace("\n" + JSON.stringify(result, null, 2));
+        logger.error("\n" + z4.prettifyError(error));
+      } else {
+        logger.error(error);
+      }
+      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
+    }
+  }
+  async runQuery(query, options, requesterDetails) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const meta = this.buildQueryMetadata(requesterDetails);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
+`;
+    const startTime = process.hrtime();
+    try {
+      const response = await this.query(queryMetadata + formattedQuery, options);
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      return response.rows;
+    } catch (error) {
+      this.logSqlStatement(formattedQuery, options, meta, startTime);
+      if (error?.routine === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+  async runQuerySchema(query, params, requesterDetails, zodSchema) {
+    const result = await this.runQuery(query, params, requesterDetails);
+    try {
+      return z4.array(zodSchema).parse(result);
+    } catch (error) {
+      if (error instanceof z4.ZodError) {
+        logger.error("Invalid data returned from database:");
+        logger.trace("\n" + JSON.stringify(result, null, 2));
+        logger.error("\n" + z4.prettifyError(error));
+      } else {
+        logger.error(error);
+      }
+      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
+    }
+  }
+  logSqlStatement(query, options, queryMetadata, startTime, prefix = "") {
+    if (logger.level !== "trace") return;
+    const sqlStatement = query.replace(/\$(\d+)/g, (_, num) => {
+      const paramIndex = parseInt(num) - 1;
+      if (paramIndex >= options.length) return "INVALID_PARAM_INDEX";
+      return toSqlLiteral(options[paramIndex]);
+    });
+    const formattedSql = sqlFormat(sqlStatement, {
+      language: "postgresql",
+      linesBetweenQueries: 2,
+      indentStyle: "standard",
+      keywordCase: "upper",
+      useTabs: true,
+      tabWidth: 4
+    });
+    const [seconds, nanoseconds] = process.hrtime(startTime);
+    const durationMs = seconds * 1e3 + nanoseconds / 1e6;
+    let initiator = "Anonymous";
+    const initiatorId = queryMetadata.userId ?? queryMetadata.adminUserId;
+    if (initiatorId) initiator = `User Id (${initiatorId.toString()})`;
+    if ("isSystemUser" in queryMetadata && queryMetadata.isSystemUser) initiator = "SYSTEM";
+    logger.trace(`${prefix}query by ${initiator}, Query ->
+${formattedSql}`, {
+      durationMs
+    });
+  }
+};
+
+// src/restura/sql/PsqlEngine.ts
+import { ObjectUtils as ObjectUtils3 } from "@redskytech/core-utils";
+import pg4 from "pg";
+
 // src/restura/sql/SqlEngine.ts
 import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
 var SqlEngine = class {
@@ -2037,893 +2230,945 @@ var SqlEngine = class {
   }
 };
 
-// src/restura/sql/filterPsqlParser.ts
-import peg from "pegjs";
-var initializers = `
-    // Quotes a SQL identifier (column/table name) with double quotes, escaping any embedded quotes
-    function quoteSqlIdentity(value) {
-        return '"' + value.replace(/"/g, '""') + '"';
-    }
-
-    // Unescape special characters in values: \\, -> , | \\| -> | | \\\\ -> \\
-    function unescapeValue(str) {
-        var result = '';
-        for (var i = 0; i < str.length; i++) {
-            if (str[i] === '\\\\' && i + 1 < str.length) {
-                var next = str[i + 1];
-                if (next === ',' || next === '|' || next === '\\\\') {
-                    result += next;
-                    i++;
-                } else {
-                    result += str[i];
-                }
-            } else {
-                result += str[i];
-            }
-        }
-        return result;
+// src/restura/sql/PsqlTransaction.ts
+import pg from "pg";
+var { Client } = pg;
+var PsqlTransaction = class extends PsqlConnection {
+  constructor(clientConfig, instanceId) {
+    super(instanceId);
+    this.clientConfig = clientConfig;
+    this.client = new Client(clientConfig);
+    this.connectPromise = this.client.connect();
+    this.beginTransactionPromise = this.beginTransaction();
+  }
+  client;
+  beginTransactionPromise;
+  connectPromise;
+  async close() {
+    if (this.client) {
+      await this.client.end();
     }
+  }
+  async beginTransaction() {
+    await this.connectPromise;
+    return this.client.query("BEGIN");
+  }
+  async rollback() {
+    return this.query("ROLLBACK");
+  }
+  async commit() {
+    return this.query("COMMIT");
+  }
+  async release() {
+    return this.client.end();
+  }
+  async query(query, values) {
+    await this.connectPromise;
+    await this.beginTransactionPromise;
+    return this.client.query(query, values);
+  }
+};
 
-    // Split pipe-separated values respecting escaped pipes
-    function splitPipeValues(str) {
-        var values = [];
-        var current = '';
-        for (var i = 0; i < str.length; i++) {
-            if (str[i] === '\\\\' && i + 1 < str.length && str[i + 1] === '|') {
-                current += '|';
-                i++;
-            } else if (str[i] === '|') {
-                values.push(unescapeValue(current));
-                current = '';
-            } else {
-                current += str[i];
-            }
-        }
-        if (current.length > 0) {
-            values.push(unescapeValue(current));
-        }
-        return values;
-    }
+// src/restura/sql/psqlSchemaUtils.ts
+import getDiff from "@wmfs/pg-diff-sync";
+import pgInfo from "@wmfs/pg-info";
+import pg3 from "pg";
 
-    // Build SQL IN clause from pipe-separated values
-    function buildInClause(column, rawValue) {
-        var values = splitPipeValues(rawValue);
-        var literals = values.map(function(v) { return formatValue(v); });
-        return column + ' IN (' + literals.join(', ') + ')';
+// src/restura/sql/PsqlPool.ts
+import pg2 from "pg";
+var { Pool } = pg2;
+var PsqlPool = class extends PsqlConnection {
+  constructor(poolConfig) {
+    super();
+    this.poolConfig = poolConfig;
+    if (poolConfig.connectionString) {
+      let url;
+      try {
+        url = new URL(poolConfig.connectionString);
+      } catch {
+        throw new Error(`Invalid connectionString: ${poolConfig.connectionString}`);
+      }
+      poolConfig.host = url.hostname;
+      poolConfig.port = url.port ? parseInt(url.port) : 5432;
+      poolConfig.user = url.username;
+      poolConfig.password = url.password;
+      poolConfig.database = url.pathname.replace(/^\//, "");
     }
+    this.pool = new Pool(poolConfig);
+    this.queryOne("SELECT NOW();", [], {
+      isSystemUser: true,
+      role: "",
+      host: "localhost",
+      ipAddress: "",
+      scopes: []
+    }).then(() => {
+      logger.info("Connected to PostgreSQL database");
+    }).catch((error) => {
+      logger.error("Error connecting to database", error);
+      process.exit(1);
+    });
+  }
+  pool;
+  async query(query, values) {
+    return this.pool.query(query, values);
+  }
+};
 
-    // Check if a value is numeric and format appropriately
-    function formatValue(value) {
-        // Check if the value is a valid number (integer or decimal)
-        if (/^-?\\d+(\\.\\d+)?$/.test(value)) {
-            return value; // Return as-is without quotes
-        }
-        return format.literal(value);
-    }
-
-    // Format a value with optional type cast
-    function formatValueWithCast(rawValue, cast) {
-        var formatted = formatValue(unescapeValue(rawValue));
-        return cast ? formatted + '::' + cast : formatted;
-    }
-
-    // Build SQL IN clause from pipe-separated values with optional cast
-    function buildInClauseWithCast(column, rawValue, cast) {
-        var values = splitPipeValues(rawValue);
-        var literals = values.map(function(v) {
-            var formatted = formatValue(v);
-            return cast ? formatted + '::' + cast : formatted;
-        });
-        return column + ' IN (' + literals.join(', ') + ')';
-    }
-
-    // Format column with optional cast
-    function formatColumn(col) {
-        if (!col.cast) {
-            return col.sql;
-        }
-        // Wrap JSON field extractions in parentheses when casting
-        // because :: has higher precedence than ->>
-        if (col.isJsonField) {
-            return '(' + col.sql + ')::' + col.cast;
-        }
-        return col.sql + '::' + col.cast;
-    }
-`;
-var entryGrammar = `
-{
-    ${initializers}
+// src/restura/sql/psqlSchemaUtils.ts
+var { Client: Client2 } = pg3;
+var systemUser = {
+  role: "",
+  scopes: [],
+  host: "",
+  ipAddress: "",
+  isSystemUser: true
+};
+function schemaToPsqlType(column) {
+  if (column.hasAutoIncrement) return "BIGSERIAL";
+  if (column.type === "ENUM") return "TEXT";
+  if (column.type === "DATETIME") return "TIMESTAMPTZ";
+  if (column.type === "MEDIUMINT") return "INT";
+  return column.type;
 }
-
-Start 
-    = sql:StartOld { return { sql: sql, usedOldSyntax: true }; }
-    / sql:StartNew { return { sql: sql, usedOldSyntax: false }; }
+var OUTBOX_TABLE_NAME = "dbEventOutbox";
+var DEFAULT_OUTBOX_CHANNEL = "restura_outbox";
+var SENSITIVE_COLUMN_PATTERN = /password|token|secret|credential|guid|key$/i;
+function isSensitiveColumnName(columnName) {
+  return SENSITIVE_COLUMN_PATTERN.test(columnName);
+}
+function createOutboxTableSql() {
+  return `
+CREATE TABLE IF NOT EXISTS "${OUTBOX_TABLE_NAME}"
+(
+	"id" BIGSERIAL PRIMARY KEY,
+	"createdOn" TIMESTAMPTZ NOT NULL DEFAULT now(),
+	"tableName" TEXT NOT NULL,
+	"operation" TEXT NOT NULL,
+	"recordId" BIGINT NULL,
+	"record" JSONB NULL,
+	"previousRecord" JSONB NULL,
+	"queryMetadata" JSONB NULL,
+	"processedOn" TIMESTAMPTZ NULL,
+	"attempts" INT NOT NULL DEFAULT 0,
+	"nextAttemptOn" TIMESTAMPTZ NULL,
+	"isDeadLetter" BOOLEAN NOT NULL DEFAULT FALSE
+);
+CREATE INDEX IF NOT EXISTS "${OUTBOX_TABLE_NAME}_unprocessed_index" ON "${OUTBOX_TABLE_NAME}" ("id") WHERE "processedOn" IS NULL AND "isDeadLetter" = FALSE;
+CREATE INDEX IF NOT EXISTS "${OUTBOX_TABLE_NAME}_processedOn_index" ON "${OUTBOX_TABLE_NAME}" ("processedOn") WHERE "processedOn" IS NOT NULL;
 `;
-var oldGrammar = `
-StartOld
-    = OldExpressionList
-_
-    = [ \\t\\r\\n]*  // Matches spaces, tabs, and line breaks
-
-OldExpressionList
-    = leftExpression:OldExpression _ operator:OldOperator _ rightExpression:OldExpressionList 
-        { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
-    / OldExpression
-
-OldExpression
-    = negate:OldNegate? _ "(" _ "column" _ ":"  column:OldColumn _ ","? _ value:OldValue? ","? _ type:OldType? _ ")"_
-        {return \`\${negate? " NOT " : ""}(\${type ? type(column, value) : (value == null ? \`\${column} IS NULL\` : \`\${column} = \${formatValue(value)}\`)})\`;}
-    /
-    negate:OldNegate?"("expression:OldExpressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
-
-OldNegate
-    = "!"
-    
-OldOperator
-    = "and"i / "or"i
-
-OldColumn
-    = first:OldColumnPart rest:("." OldColumnPart)* { 
-        const partsArray = [first];
-        if (rest && rest.length > 0) {
-            partsArray.push(...rest.map(item => item[1]));
-        }
-        
-        if (partsArray.length > 3) {
-            throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
-        }
-        
-        if (partsArray.length === 1) {
-            return quoteSqlIdentity(partsArray[0]);
-        }
-        const tableName = quoteSqlIdentity(partsArray[0]);
-        
-        // If we only have two parts (table.column), use regular dot notation
-        if (partsArray.length === 2) {
-            return tableName + "." + quoteSqlIdentity(partsArray[1]);
-        }
-        
-        // For JSON paths (more than 2 parts), first part is a column, last part uses ->>
-        const jsonColumn = quoteSqlIdentity(partsArray[1]);
-        const lastPart = partsArray[partsArray.length - 1];
-        const escapedLast = lastPart.replace(/'/g, "''");
-        const result = tableName + "." + jsonColumn + "->>'" + escapedLast + "'";
-        return result;
+}
+function resolveNotifyColumns(tableName, notify, tableColumns) {
+  if (!notify) return [];
+  let columns;
+  if (notify === "ALL") {
+    if (!tableColumns) {
+      throw new Error(
+        `notify: "ALL" on table "${tableName}" requires tableColumns so the sensitive-column denylist can be applied. Pass options.tableColumns or list columns explicitly.`
+      );
     }
+    columns = tableColumns.filter((column) => !isSensitiveColumnName(column));
+  } else {
+    columns = notify.map((entry) => {
+      if (entry.startsWith("!")) return entry.slice(1);
+      if (isSensitiveColumnName(entry)) {
+        throw new Error(
+          `Refusing to include sensitive column "${tableName}"."${entry}" in notify trigger payloads. Remove it from the notify list or prefix it with '!' to force-include it.`
+        );
+      }
+      return entry;
+    });
+  }
+  if (!columns.length) {
+    throw new Error(
+      `notify config on table "${tableName}" resolves to no columns \u2014 remove the notify key or list at least one column.`
+    );
+  }
+  return columns;
+}
+function sqlStringLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+function buildRowJson(rowVariable, columns) {
+  return `jsonb_build_object(
+							${columns.map((column) => `'${sqlStringLiteral(column)}', ${rowVariable}."${column}"`).join(",\n							")}
+						)`;
+}
+var QUERY_METADATA_DECLARE_BLOCK = `
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+`;
+function buildTriggerFunctionSql(tableName, operation, notify, options) {
+  if (!notify) return "";
+  const columns = resolveNotifyColumns(tableName, notify, options?.tableColumns);
+  const delivery = options?.delivery || "direct";
+  const channel = options?.channel || DEFAULT_OUTBOX_CHANNEL;
+  const tableNameLiteral = sqlStringLiteral(tableName);
+  const channelLiteral = sqlStringLiteral(channel);
+  const functionName = `notify_${tableName}_${operation}`;
+  const rowVariable = operation === "delete" ? "OLD" : "NEW";
+  let body;
+  if (delivery === "outbox") {
+    const recordJson = operation === "delete" ? "NULL" : buildRowJson("NEW", columns);
+    const previousRecordJson = operation === "insert" ? "NULL" : buildRowJson("OLD", columns);
+    body = `	INSERT INTO "${OUTBOX_TABLE_NAME}" ("tableName", "operation", "recordId", "record", "previousRecord", "queryMetadata")
+	VALUES ('${tableNameLiteral}', '${operation.toUpperCase()}', ${rowVariable}.id, ${recordJson}, ${previousRecordJson}, query_metadata::jsonb)
+	RETURNING "id" INTO outbox_id;
 
-OldColumnPart
-    = text:[a-z0-9 \\t\\r\\n\\-_:@']i+ {
-        return text.join(""); 
-    }
+	PERFORM pg_notify('${channelLiteral}', outbox_id::text);`;
+  } else {
+    const idField = operation === "insert" ? `'insertedId', NEW.id` : operation === "update" ? `'changedId', NEW.id` : `'deletedId', OLD.id`;
+    const payloadFields = [`'table', '${tableNameLiteral}'`, `'queryMetadata', query_metadata`, idField];
+    if (operation !== "delete") payloadFields.push(`'record', ${buildRowJson("NEW", columns)}`);
+    if (operation !== "insert") payloadFields.push(`'previousRecord', ${buildRowJson("OLD", columns)}`);
+    body = `	PERFORM pg_notify(
+		'${operation}',
+		json_build_object(
+						${payloadFields.join(",\n						")}
+		)::text
+		);`;
+  }
+  const outboxDeclare = delivery === "outbox" ? "\n	outbox_id BIGINT;" : "";
+  const legacyDrop = operation === "update" && tableName !== tableName.toLowerCase() ? `DROP TRIGGER IF EXISTS ${tableName}_update ON "${tableName}";
+` : "";
+  let updateScope = "";
+  let updateGuard = "";
+  if (operation === "update") {
+    updateScope = ` OF ${columns.map((column) => `"${column}"`).join(", ")}`;
+    updateGuard = `
+	WHEN (${columns.map((column) => `OLD."${column}" IS DISTINCT FROM NEW."${column}"`).join(" OR ")})`;
+  }
+  return `
+CREATE OR REPLACE FUNCTION ${functionName}()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;${outboxDeclare}
+BEGIN
+${QUERY_METADATA_DECLARE_BLOCK}
+${body}
 
-OldText
-    = text:[a-z0-9 \\t\\r\\n\\-_:@'.]i+ {
-        return text.join(""); 
-    }
+	RETURN ${rowVariable};
+END;
+$$ LANGUAGE plpgsql;
 
-OldType
-    = "type" _ ":" _ type:OldTypeString {
-        return type; 
+${legacyDrop}CREATE OR REPLACE TRIGGER "${tableName}_${operation}"
+	AFTER ${operation.toUpperCase()}${updateScope} ON "${tableName}"
+	FOR EACH ROW${updateGuard}
+EXECUTE FUNCTION ${functionName}();
+`;
+}
+function createInsertTriggerSql(tableName, notify, options) {
+  return buildTriggerFunctionSql(tableName, "insert", notify, options);
+}
+function createUpdateTriggerSql(tableName, notify, options) {
+  return buildTriggerFunctionSql(tableName, "update", notify, options);
+}
+function createDeleteTriggerSql(tableName, notify, options) {
+  return buildTriggerFunctionSql(tableName, "delete", notify, options);
+}
+function generateNotifyTriggersSql(schema, options) {
+  const statements = [];
+  const hasNotifyTables = schema.database.some((table) => table.notify);
+  if (options?.eventDelivery === "outbox" && hasNotifyTables) {
+    statements.push(createOutboxTableSql());
+  }
+  for (const table of schema.database) {
+    if (!table.notify) continue;
+    const triggerOptions = {
+      delivery: options?.eventDelivery,
+      channel: options?.outboxChannel,
+      tableColumns: table.columns.map((column) => column.name)
+    };
+    statements.push(createInsertTriggerSql(table.name, table.notify, triggerOptions));
+    statements.push(createUpdateTriggerSql(table.name, table.notify, triggerOptions));
+    statements.push(createDeleteTriggerSql(table.name, table.notify, triggerOptions));
+  }
+  return statements;
+}
+function generateDatabaseSchemaFromSchema(schema, options) {
+  const sqlStatements = [];
+  const indexes = [];
+  const triggers = generateNotifyTriggersSql(schema, options);
+  for (const table of schema.database) {
+    let sql = `CREATE TABLE "${table.name}"
+				   ( `;
+    const tableColumns = [];
+    for (const column of table.columns) {
+      let columnSql = "";
+      columnSql += `	"${column.name}" ${schemaToPsqlType(column)}`;
+      let value = column.value;
+      if (column.type === "JSON") value = "";
+      if (column.type === "JSONB") value = "";
+      if (column.type === "DECIMAL" && value) {
+        value = value.replace("-", ",").replace(/['"]/g, "");
+      }
+      if (value && column.type !== "ENUM") {
+        columnSql += `(${value})`;
+      } else if (column.length) columnSql += `(${column.length})`;
+      if (column.isPrimary) {
+        columnSql += " PRIMARY KEY ";
+      }
+      if (column.isUnique) {
+        columnSql += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE `;
+      }
+      if (column.isNullable) columnSql += " NULL";
+      else columnSql += " NOT NULL";
+      if (column.default) columnSql += ` DEFAULT ${column.default}`;
+      if (value && column.type === "ENUM") {
+        columnSql += ` CHECK ("${column.name}" IN (${value}))`;
+      }
+      tableColumns.push(columnSql);
     }
-
-OldTypeString
-    = text:"startsWith" { return function(column, value) { return \`\${column} ILIKE '\${format.literal(value).slice(1,-1)}%'\`; } }
-    / text:"endsWith"  { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}'\`; } }
-    / text:"contains" { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}%'\`; } }
-    / text:"exact" { return function(column, value)    { return \`\${column} = \${formatValue(value)}\`; } }
-    / text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= \${formatValue(value)}\`; } }
-    / text:"greaterThan" { return function(column, value) { return \`\${column} > \${formatValue(value)}\`; } }
-    / text:"lessThanEqual" { return function(column, value) { return \`\${column} <= \${formatValue(value)}\`; } }
-    / text:"lessThan" { return function(column, value) { return \`\${column} < \${formatValue(value)}\`; } }
-    / text:"isNull"   { return function(column, value) { return \`\${column} IS NULL\`; } }
-
-OldValue
-    = "value" _ ":" value:OldText {
-        return value; 
+    sql += tableColumns.join(", \n");
+    for (const index of table.indexes) {
+      if (!index.isPrimaryKey) {
+        let unique = " ";
+        if (index.isUnique) unique = "UNIQUE ";
+        let indexSQL = `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}"`;
+        indexSQL += ` (${index.columns.map((item) => `"${item}" ${index.order}`).join(", ")})`;
+        indexSQL += index.where ? ` WHERE ${index.where}` : "";
+        indexSQL += ";";
+        indexes.push(indexSQL);
+      }
     }
-`;
-var newGrammar = `
-StartNew
-    = ExpressionList
-
-ExpressionList
-    = left:Expression _ op:("and"i / "or"i) _ right:ExpressionList
-        { return left + ' ' + op.toUpperCase() + ' ' + right; }
-    / Expression
-
-Expression
-    = negate:"!"? _ "(" _ inner:SimpleExprList _ ")" _
-        { return (negate ? 'NOT ' : '') + '(' + inner + ')'; }
-    / SimpleExpr
-
-SimpleExprList
-    = left:SimpleExpr _ op:("and"i / "or"i) _ right:SimpleExprList
-        { return left + ' ' + op.toUpperCase() + ' ' + right; }
-    / SimpleExpr
-
-SimpleExpr
-    = negate:"!"? _ "(" _ col:Column _ "," _ op:OperatorWithValue _ ")" _
-        { return (negate ? 'NOT ' : '') + '(' + op(col) + ')'; }
-    / negate:"!"? _ "(" _ col:Column _ "," _ op:NullOperator _ ")" _
-        { return (negate ? 'NOT ' : '') + '(' + op(col) + ')'; }
-    / negate:"!"? _ "(" _ col:Column _ "," _ val:CastedValue _ ")" _
-        { return (negate ? 'NOT ' : '') + '(' + formatColumn(col) + ' = ' + formatValueWithCast(val.value, val.cast) + ')'; }
-
-Column
-    = first:ColPart rest:("." ColPart)* cast:TypeCast? {
-        const partsArray = [first];
-        if (rest && rest.length > 0) {
-            partsArray.push(...rest.map(item => item[1]));
-        }
-        
-        if (partsArray.length > 3) {
-            throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
-        }
-        
-        var sql;
-        var isJsonField = false;
-        if (partsArray.length === 1) {
-            sql = quoteSqlIdentity(partsArray[0]);
-        } else {
-            const tableName = quoteSqlIdentity(partsArray[0]);
-            
-            if (partsArray.length === 2) {
-                sql = tableName + '.' + quoteSqlIdentity(partsArray[1]);
-            } else {
-                const jsonColumn = quoteSqlIdentity(partsArray[1]);
-                const lastPart = partsArray[partsArray.length - 1];
-                const escapedLast = lastPart.replace(/'/g, "''");
-                sql = tableName + '.' + jsonColumn + "->>'" + escapedLast + "'";
-                isJsonField = true;
-            }
-        }
-        
-        return { sql: sql, cast: cast, isJsonField: isJsonField };
+    sql += "\n);";
+    sqlStatements.push(sql);
+  }
+  for (const table of schema.database) {
+    if (!table.foreignKeys.length) continue;
+    const sql = `ALTER TABLE "${table.name}" `;
+    const constraints = [];
+    for (const foreignKey of table.foreignKeys) {
+      let constraint = `	 ADD CONSTRAINT "${foreignKey.name}"
+        FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}")`;
+      constraint += ` ON DELETE ${foreignKey.onDelete}`;
+      constraint += ` ON UPDATE ${foreignKey.onUpdate}`;
+      constraints.push(constraint);
     }
-
-ColPart
-    = chars:[a-zA-Z0-9_]+ { return chars.join(''); }
-
-NullOperator
-    = "notnull"i { return function(col) { return formatColumn(col) + ' IS NOT NULL'; }; }
-    / "null"i { return function(col) { return formatColumn(col) + ' IS NULL'; }; }
-
-OperatorWithValue
-    = "in"i _ "," _ vals:InValueList cast:TypeCast? { return function(col) { 
-        var formattedCol = formatColumn(col);
-        var literals = vals.map(function(v) {
-            var unescaped = unescapeValue(v);
-            var formatted = formatValue(unescaped);
-            return cast ? formatted + '::' + cast : formatted;
-        });
-        return formattedCol + ' IN (' + literals.join(', ') + ')';
-    }; }
-    / "ne"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' <> ' + formatValueWithCast(val.value, val.cast); }; }
-    / "gte"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' >= ' + formatValueWithCast(val.value, val.cast); }; }
-    / "gt"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' > ' + formatValueWithCast(val.value, val.cast); }; }
-    / "lte"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' <= ' + formatValueWithCast(val.value, val.cast); }; }
-    / "lt"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' < ' + formatValueWithCast(val.value, val.cast); }; }
-    / "has"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value) + '%'); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
-    / "sw"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal(unescapeValue(val.value) + '%'); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
-    / "ew"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value)); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
-
-InValueList
-    = first:InValue rest:("|" InValue)* {
-        var values = [first];
-        for (var i = 0; i < rest.length; i++) {
-            values.push(rest[i][1]);
-        }
-        return values;
+    sqlStatements.push(sql + constraints.join(",\n") + ";");
+  }
+  for (const table of schema.database) {
+    if (!table.checkConstraints.length) continue;
+    const sql = `ALTER TABLE "${table.name}" `;
+    const constraints = [];
+    for (const check of table.checkConstraints) {
+      const constraint = `ADD CONSTRAINT "${check.name}" CHECK (${check.check})`;
+      constraints.push(constraint);
     }
+    sqlStatements.push(sql + constraints.join(",\n") + ";");
+  }
+  sqlStatements.push(indexes.join("\n"));
+  sqlStatements.push(triggers.join("\n"));
+  return sqlStatements.join("\n\n");
+}
+async function getNewPublicSchemaAndScratchPool(targetPool, scratchDbName) {
+  const scratchDbExists = await targetPool.runQuery(
+    `SELECT * FROM pg_database WHERE datname = ?;`,
+    [scratchDbName],
+    systemUser
+  );
+  if (scratchDbExists.length === 0) {
+    await targetPool.runQuery(`CREATE DATABASE ${escapeColumnName(scratchDbName)};`, [], systemUser);
+  }
+  const scratchPool = new PsqlPool({
+    host: targetPool.poolConfig.host,
+    port: targetPool.poolConfig.port,
+    user: targetPool.poolConfig.user,
+    database: scratchDbName,
+    password: targetPool.poolConfig.password,
+    max: targetPool.poolConfig.max,
+    idleTimeoutMillis: targetPool.poolConfig.idleTimeoutMillis,
+    connectionTimeoutMillis: targetPool.poolConfig.connectionTimeoutMillis
+  });
+  await scratchPool.runQuery(`DROP SCHEMA public CASCADE;`, [], systemUser);
+  await scratchPool.runQuery(
+    `CREATE SCHEMA public AUTHORIZATION ${escapeColumnName(targetPool.poolConfig.user)};`,
+    [],
+    systemUser
+  );
+  const schemaComment = await targetPool.runQuery(
+    `
+		SELECT pg_description.description
+		FROM pg_description
+		JOIN pg_namespace ON pg_namespace.oid = pg_description.objoid
+		WHERE pg_namespace.nspname = 'public';`,
+    [],
+    systemUser
+  );
+  if (schemaComment[0]?.description) {
+    const escaped = schemaComment[0].description.replace(/'/g, "''");
+    await scratchPool.runQuery(`COMMENT ON SCHEMA public IS '${escaped}';`, [], systemUser);
+  }
+  return scratchPool;
+}
+async function diffDatabaseToSchema(schema, targetPool, scratchDbName, options) {
+  let scratchPool;
+  let originalClient;
+  let scratchClient;
+  try {
+    scratchPool = await getNewPublicSchemaAndScratchPool(targetPool, scratchDbName);
+    const sqlFullStatement = generateDatabaseSchemaFromSchema(schema, options);
+    await scratchPool.runQuery(sqlFullStatement, [], systemUser);
+    const connectionConfig = {
+      host: targetPool.poolConfig.host,
+      port: targetPool.poolConfig.port,
+      user: targetPool.poolConfig.user,
+      password: targetPool.poolConfig.password,
+      ssl: targetPool.poolConfig.ssl
+    };
+    originalClient = new Client2({ ...connectionConfig, database: targetPool.poolConfig.database });
+    scratchClient = new Client2({ ...connectionConfig, database: scratchDbName });
+    await Promise.all([originalClient.connect(), scratchClient.connect()]);
+    const [info1, info2] = await Promise.all([
+      pgInfo({ client: originalClient }),
+      pgInfo({ client: scratchClient })
+    ]);
+    const diff = getDiff(info1, info2);
+    return diff.join("\n");
+  } finally {
+    const cleanups = [];
+    if (originalClient) cleanups.push(originalClient.end());
+    if (scratchClient) cleanups.push(scratchClient.end());
+    if (scratchPool) cleanups.push(scratchPool.pool.end());
+    await Promise.allSettled(cleanups);
+  }
+}
 
-InValue
-    = QuotedString
-    / chars:InValueChar+ { return chars.join(''); }
-
-InValueChar
-    = "\\\\\\\\" { return '\\\\\\\\'; }
-    / "\\\\," { return '\\\\,'; }
-    / "\\\\|" { return '\\\\|'; }
-    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" ]
-    / c:":" !":"  { return c; }
-
-CastedValue
-    = val:Value cast:TypeCast? { return { value: val, cast: cast }; }
-
-CastedValueWithPipes
-    = val:ValueWithPipes cast:TypeCast? { return { value: val, cast: cast }; }
-
-TypeCast
-    = "::" type:("timestamptz"i / "timestamp"i / "boolean"i / "numeric"i / "bigint"i / "text"i / "date"i / "int"i)
-        { return type.toLowerCase(); }
-
-QuotedString
-    = '"' chars:DoubleQuotedChar* '"' { return chars.join(''); }
-    / "'" chars:SingleQuotedChar* "'" { return chars.join(''); }
-
-DoubleQuotedChar
-    = '\\\\"' { return '"'; }
-    / '\\\\\\\\' { return '\\\\'; }
-    / [^"\\\\]
-
-SingleQuotedChar
-    = "\\\\'" { return "'"; }
-    / '\\\\\\\\' { return '\\\\'; }
-    / [^'\\\\]
-
-Value
-    = QuotedString
-    / chars:ValueChar+ { return chars.join(''); }
-
-ValueChar
-    = "\\\\\\\\" { return '\\\\\\\\'; }
-    / "\\\\," { return '\\\\,'; }
-    / "\\\\|" { return '\\\\|'; }
-    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" ]
-    / c:":" !":"  { return c; }
-
-ValueWithPipes
-    = QuotedString
-    / chars:ValueWithPipesChar+ { return chars.join(''); }
-
-ValueWithPipesChar
-    = "\\\\\\\\" { return '\\\\\\\\'; }
-    / "\\\\," { return '\\\\,'; }
-    / "\\\\|" { return '\\\\|'; }
-    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" |]
-    / c:":" !":"  { return c; }
-`;
-var fullGrammar = entryGrammar + oldGrammar + newGrammar;
-var filterPsqlParser = peg.generate(fullGrammar, {
-  format: "commonjs",
-  dependencies: { format: "pg-format" }
-});
-var filterPsqlParser_default = filterPsqlParser;
-
-// src/restura/sql/psqlSchemaUtils.ts
-import getDiff from "@wmfs/pg-diff-sync";
-import pgInfo from "@wmfs/pg-info";
-import pg2 from "pg";
-
-// src/restura/sql/PsqlPool.ts
-import pg from "pg";
-
-// src/restura/sql/PsqlConnection.ts
-import crypto from "crypto";
-import { format as sqlFormat } from "sql-formatter";
-import { z as z4 } from "zod";
-var PsqlConnection = class {
-  instanceId;
-  constructor(instanceId) {
-    this.instanceId = instanceId || crypto.randomUUID();
+// src/restura/sql/eventOutbox.ts
+var defaultEventOutboxOptions = {
+  channel: DEFAULT_OUTBOX_CHANNEL,
+  pollIntervalMs: 15e3,
+  batchSize: 50,
+  maxAttempts: 5,
+  pruneAfterDays: 7
+};
+var PRUNE_INTERVAL_MS = 60 * 60 * 1e3;
+var EventOutboxConsumer = class {
+  constructor(psqlConnectionPool, options) {
+    this.psqlConnectionPool = psqlConnectionPool;
+    this.options = { ...defaultEventOutboxOptions, ...options };
   }
-  async queryOne(query, options, requesterDetails) {
-    const formattedQuery = questionMarksToOrderedParams(query);
-    const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
-    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
-`;
-    const startTime = process.hrtime();
-    try {
-      const response = await this.query(queryMetadata + formattedQuery, options);
-      if (response.rows.length === 0) throw new RsError("NOT_FOUND", "No results found");
-      else if (response.rows.length > 1) throw new RsError("DUPLICATE", "More than one result found");
-      this.logSqlStatement(formattedQuery, options, meta, startTime);
-      return response.rows[0];
-    } catch (error) {
-      this.logSqlStatement(formattedQuery, options, meta, startTime);
-      if (RsError.isRsError(error)) throw error;
-      if (error?.routine === "_bt_check_unique") {
-        throw new RsError("DUPLICATE", error.message);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
+  options;
+  isDraining = false;
+  drainRequested = false;
+  isStopped = false;
+  pollTimer;
+  pruneTimer;
+  activeDrain = Promise.resolve();
+  lastDrainOn = null;
+  get channel() {
+    return this.options.channel;
+  }
+  start() {
+    this.isStopped = false;
+    this.pollTimer = setInterval(() => void this.drain(), this.options.pollIntervalMs);
+    this.pruneTimer = setInterval(() => void this.prune(), PRUNE_INTERVAL_MS);
+    void this.drain();
+    void this.prune();
+  }
+  async stop() {
+    this.isStopped = true;
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.pruneTimer) clearInterval(this.pruneTimer);
+    await this.activeDrain;
+  }
+  /** Safe to call at any frequency; overlapping calls coalesce into one extra pass. */
+  async drain() {
+    if (this.isDraining) {
+      this.drainRequested = true;
+      return;
     }
+    this.isDraining = true;
+    this.activeDrain = (async () => {
+      try {
+        do {
+          this.drainRequested = false;
+          let processedCount = 0;
+          do {
+            processedCount = await this.processBatch();
+          } while (processedCount > 0 && !this.isStopped);
+        } while (this.drainRequested && !this.isStopped);
+        this.lastDrainOn = (/* @__PURE__ */ new Date()).toISOString();
+      } catch (error) {
+        logger.error(`Event outbox drain failed: ${error}`);
+      } finally {
+        this.isDraining = false;
+      }
+    })();
+    await this.activeDrain;
   }
-  async queryOneSchema(query, params, requesterDetails, zodSchema) {
-    const result = await this.queryOne(query, params, requesterDetails);
+  async getStats() {
+    const result = await this.psqlConnectionPool.runQuery(
+      `SELECT
+				COUNT(*) FILTER (WHERE "processedOn" IS NULL AND "isDeadLetter" = FALSE) AS "pendingCount",
+				COUNT(*) FILTER (WHERE "isDeadLetter" = TRUE) AS "deadLetterCount"
+			FROM "${OUTBOX_TABLE_NAME}";`,
+      [],
+      systemUser
+    );
+    return {
+      pendingCount: Number(result[0]?.pendingCount || 0),
+      deadLetterCount: Number(result[0]?.deadLetterCount || 0),
+      lastDrainOn: this.lastDrainOn
+    };
+  }
+  async processBatch() {
+    const transaction = new PsqlTransaction({
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port,
+      user: this.psqlConnectionPool.poolConfig.user,
+      password: this.psqlConnectionPool.poolConfig.password,
+      database: this.psqlConnectionPool.poolConfig.database,
+      connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
+    });
     try {
-      return zodSchema.parse(result);
+      const rows = await transaction.runQuery(
+        `SELECT * FROM "${OUTBOX_TABLE_NAME}"
+				WHERE "processedOn" IS NULL AND "isDeadLetter" = FALSE
+				AND ("nextAttemptOn" IS NULL OR "nextAttemptOn" <= now())
+				ORDER BY "id"
+				LIMIT ?
+				FOR UPDATE SKIP LOCKED;`,
+        [this.options.batchSize],
+        systemUser
+      );
+      for (const row of rows) {
+        await this.processRow(transaction, row);
+      }
+      await transaction.commit();
+      return rows.length;
     } catch (error) {
-      if (error instanceof z4.ZodError) {
-        logger.error("Invalid data returned from database:");
-        logger.trace("\n" + JSON.stringify(result, null, 2));
-        logger.error("\n" + z4.prettifyError(error));
-      } else {
-        logger.error(error);
+      try {
+        await transaction.rollback();
+      } catch {
       }
-      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
+      throw error;
+    } finally {
+      await transaction.release();
     }
   }
-  async runQuery(query, options, requesterDetails) {
-    const formattedQuery = questionMarksToOrderedParams(query);
-    const meta = { connectionInstanceId: this.instanceId, ...requesterDetails };
-    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
-`;
-    const startTime = process.hrtime();
+  async processRow(transaction, row) {
     try {
-      const response = await this.query(queryMetadata + formattedQuery, options);
-      this.logSqlStatement(formattedQuery, options, meta, startTime);
-      return response.rows;
+      const triggerResult = {
+        table: row.tableName,
+        insertedId: row.operation === "INSERT" ? row.recordId ?? void 0 : void 0,
+        changedId: row.operation === "UPDATE" ? row.recordId ?? void 0 : void 0,
+        deletedId: row.operation === "DELETE" ? row.recordId ?? void 0 : void 0,
+        queryMetadata: row.queryMetadata ?? {},
+        record: row.record ?? {},
+        previousRecord: row.previousRecord ?? {},
+        requesterId: 0
+      };
+      await eventManager_default.fireActionFromDbTrigger(
+        { mutationType: row.operation, queryMetadata: triggerResult.queryMetadata },
+        triggerResult,
+        { rethrowHandlerErrors: true }
+      );
+      await transaction.runQuery(
+        `UPDATE "${OUTBOX_TABLE_NAME}" SET "processedOn" = now() WHERE "id" = ?;`,
+        [row.id],
+        systemUser
+      );
     } catch (error) {
-      this.logSqlStatement(formattedQuery, options, meta, startTime);
-      if (error?.routine === "_bt_check_unique") {
-        throw new RsError("DUPLICATE", error.message);
+      const attempts = row.attempts + 1;
+      const isDeadLetter = attempts >= this.options.maxAttempts;
+      if (isDeadLetter) {
+        logger.error(
+          `Event outbox row ${row.id} (${row.tableName} ${row.operation}) moved to dead letter after ${attempts} attempts: ${error}`
+        );
+      } else {
+        logger.warn(
+          `Event outbox row ${row.id} (${row.tableName} ${row.operation}) attempt ${attempts} failed: ${error}`
+        );
       }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
+      const backoffSeconds = 30 * Math.pow(2, row.attempts);
+      await transaction.runQuery(
+        `UPDATE "${OUTBOX_TABLE_NAME}"
+				SET "attempts" = ?, "isDeadLetter" = ?, "nextAttemptOn" = now() + (? || ' seconds')::interval
+				WHERE "id" = ?;`,
+        [attempts, isDeadLetter, backoffSeconds, row.id],
+        systemUser
+      );
     }
   }
-  async runQuerySchema(query, params, requesterDetails, zodSchema) {
-    const result = await this.runQuery(query, params, requesterDetails);
+  async prune() {
     try {
-      return z4.array(zodSchema).parse(result);
+      await this.psqlConnectionPool.runQuery(
+        `DELETE FROM "${OUTBOX_TABLE_NAME}"
+				WHERE "processedOn" IS NOT NULL
+				AND "isDeadLetter" = FALSE
+				AND "processedOn" < now() - (? || ' days')::interval;`,
+        [this.options.pruneAfterDays],
+        systemUser
+      );
     } catch (error) {
-      if (error instanceof z4.ZodError) {
-        logger.error("Invalid data returned from database:");
-        logger.trace("\n" + JSON.stringify(result, null, 2));
-        logger.error("\n" + z4.prettifyError(error));
-      } else {
-        logger.error(error);
-      }
-      throw new RsError("DATABASE_ERROR", `Invalid data returned from database`);
+      logger.error(`Event outbox prune failed: ${error}`);
     }
   }
-  logSqlStatement(query, options, queryMetadata, startTime, prefix = "") {
-    if (logger.level !== "trace") return;
-    const sqlStatement = query.replace(/\$(\d+)/g, (_, num) => {
-      const paramIndex = parseInt(num) - 1;
-      if (paramIndex >= options.length) return "INVALID_PARAM_INDEX";
-      return toSqlLiteral(options[paramIndex]);
-    });
-    const formattedSql = sqlFormat(sqlStatement, {
-      language: "postgresql",
-      linesBetweenQueries: 2,
-      indentStyle: "standard",
-      keywordCase: "upper",
-      useTabs: true,
-      tabWidth: 4
-    });
-    const [seconds, nanoseconds] = process.hrtime(startTime);
-    const durationMs = seconds * 1e3 + nanoseconds / 1e6;
-    let initiator = "Anonymous";
-    if ("userId" in queryMetadata && queryMetadata.userId)
-      initiator = `User Id (${queryMetadata.userId.toString()})`;
-    if ("isSystemUser" in queryMetadata && queryMetadata.isSystemUser) initiator = "SYSTEM";
-    logger.trace(`${prefix}query by ${initiator}, Query ->
-${formattedSql}`, {
-      durationMs
-    });
-  }
 };
 
-// src/restura/sql/PsqlPool.ts
-var { Pool } = pg;
-var PsqlPool = class extends PsqlConnection {
-  constructor(poolConfig) {
-    super();
-    this.poolConfig = poolConfig;
-    if (poolConfig.connectionString) {
-      let url;
-      try {
-        url = new URL(poolConfig.connectionString);
-      } catch {
-        throw new Error(`Invalid connectionString: ${poolConfig.connectionString}`);
-      }
-      poolConfig.host = url.hostname;
-      poolConfig.port = url.port ? parseInt(url.port) : 5432;
-      poolConfig.user = url.username;
-      poolConfig.password = url.password;
-      poolConfig.database = url.pathname.replace(/^\//, "");
+// src/restura/sql/filterPsqlParser.ts
+import peg from "pegjs";
+var initializers = `
+    // Quotes a SQL identifier (column/table name) with double quotes, escaping any embedded quotes
+    function quoteSqlIdentity(value) {
+        return '"' + value.replace(/"/g, '""') + '"';
+    }
+
+    // Unescape special characters in values: \\, -> , | \\| -> | | \\\\ -> \\
+    function unescapeValue(str) {
+        var result = '';
+        for (var i = 0; i < str.length; i++) {
+            if (str[i] === '\\\\' && i + 1 < str.length) {
+                var next = str[i + 1];
+                if (next === ',' || next === '|' || next === '\\\\') {
+                    result += next;
+                    i++;
+                } else {
+                    result += str[i];
+                }
+            } else {
+                result += str[i];
+            }
+        }
+        return result;
+    }
+
+    // Split pipe-separated values respecting escaped pipes
+    function splitPipeValues(str) {
+        var values = [];
+        var current = '';
+        for (var i = 0; i < str.length; i++) {
+            if (str[i] === '\\\\' && i + 1 < str.length && str[i + 1] === '|') {
+                current += '|';
+                i++;
+            } else if (str[i] === '|') {
+                values.push(unescapeValue(current));
+                current = '';
+            } else {
+                current += str[i];
+            }
+        }
+        if (current.length > 0) {
+            values.push(unescapeValue(current));
+        }
+        return values;
+    }
+
+    // Build SQL IN clause from pipe-separated values
+    function buildInClause(column, rawValue) {
+        var values = splitPipeValues(rawValue);
+        var literals = values.map(function(v) { return formatValue(v); });
+        return column + ' IN (' + literals.join(', ') + ')';
+    }
+
+    // Check if a value is numeric and format appropriately
+    function formatValue(value) {
+        // Check if the value is a valid number (integer or decimal)
+        if (/^-?\\d+(\\.\\d+)?$/.test(value)) {
+            return value; // Return as-is without quotes
+        }
+        return format.literal(value);
+    }
+
+    // Format a value with optional type cast
+    function formatValueWithCast(rawValue, cast) {
+        var formatted = formatValue(unescapeValue(rawValue));
+        return cast ? formatted + '::' + cast : formatted;
+    }
+
+    // Build SQL IN clause from pipe-separated values with optional cast
+    function buildInClauseWithCast(column, rawValue, cast) {
+        var values = splitPipeValues(rawValue);
+        var literals = values.map(function(v) {
+            var formatted = formatValue(v);
+            return cast ? formatted + '::' + cast : formatted;
+        });
+        return column + ' IN (' + literals.join(', ') + ')';
+    }
+
+    // Format column with optional cast
+    function formatColumn(col) {
+        if (!col.cast) {
+            return col.sql;
+        }
+        // Wrap JSON field extractions in parentheses when casting
+        // because :: has higher precedence than ->>
+        if (col.isJsonField) {
+            return '(' + col.sql + ')::' + col.cast;
+        }
+        return col.sql + '::' + col.cast;
+    }
+`;
+var entryGrammar = `
+{
+    ${initializers}
+}
+
+Start 
+    = sql:StartOld { return { sql: sql, usedOldSyntax: true }; }
+    / sql:StartNew { return { sql: sql, usedOldSyntax: false }; }
+`;
+var oldGrammar = `
+StartOld
+    = OldExpressionList
+_
+    = [ \\t\\r\\n]*  // Matches spaces, tabs, and line breaks
+
+OldExpressionList
+    = leftExpression:OldExpression _ operator:OldOperator _ rightExpression:OldExpressionList 
+        { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
+    / OldExpression
+
+OldExpression
+    = negate:OldNegate? _ "(" _ "column" _ ":"  column:OldColumn _ ","? _ value:OldValue? ","? _ type:OldType? _ ")"_
+        {return \`\${negate? " NOT " : ""}(\${type ? type(column, value) : (value == null ? \`\${column} IS NULL\` : \`\${column} = \${formatValue(value)}\`)})\`;}
+    /
+    negate:OldNegate?"("expression:OldExpressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
+
+OldNegate
+    = "!"
+    
+OldOperator
+    = "and"i / "or"i
+
+OldColumn
+    = first:OldColumnPart rest:("." OldColumnPart)* { 
+        const partsArray = [first];
+        if (rest && rest.length > 0) {
+            partsArray.push(...rest.map(item => item[1]));
+        }
+        
+        if (partsArray.length > 3) {
+            throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
+        }
+        
+        if (partsArray.length === 1) {
+            return quoteSqlIdentity(partsArray[0]);
+        }
+        const tableName = quoteSqlIdentity(partsArray[0]);
+        
+        // If we only have two parts (table.column), use regular dot notation
+        if (partsArray.length === 2) {
+            return tableName + "." + quoteSqlIdentity(partsArray[1]);
+        }
+        
+        // For JSON paths (more than 2 parts), first part is a column, last part uses ->>
+        const jsonColumn = quoteSqlIdentity(partsArray[1]);
+        const lastPart = partsArray[partsArray.length - 1];
+        const escapedLast = lastPart.replace(/'/g, "''");
+        const result = tableName + "." + jsonColumn + "->>'" + escapedLast + "'";
+        return result;
+    }
+
+OldColumnPart
+    = text:[a-z0-9 \\t\\r\\n\\-_:@']i+ {
+        return text.join(""); 
     }
-    this.pool = new Pool(poolConfig);
-    this.queryOne("SELECT NOW();", [], {
-      isSystemUser: true,
-      role: "",
-      host: "localhost",
-      ipAddress: "",
-      scopes: []
-    }).then(() => {
-      logger.info("Connected to PostgreSQL database");
-    }).catch((error) => {
-      logger.error("Error connecting to database", error);
-      process.exit(1);
-    });
-  }
-  pool;
-  async query(query, values) {
-    return this.pool.query(query, values);
-  }
-};
 
-// src/restura/sql/psqlSchemaUtils.ts
-var { Client } = pg2;
-var systemUser = {
-  role: "",
-  scopes: [],
-  host: "",
-  ipAddress: "",
-  isSystemUser: true
-};
-function schemaToPsqlType(column) {
-  if (column.hasAutoIncrement) return "BIGSERIAL";
-  if (column.type === "ENUM") return "TEXT";
-  if (column.type === "DATETIME") return "TIMESTAMPTZ";
-  if (column.type === "MEDIUMINT") return "INT";
-  return column.type;
-}
-function createInsertTriggerSql(tableName, notify) {
-  if (!notify) return "";
-  if (notify === "ALL") {
-    return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
+OldText
+    = text:[a-z0-9 \\t\\r\\n\\-_:@'.]i+ {
+        return text.join(""); 
+    }
 
-	PERFORM pg_notify(
-		'insert',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'insertedId', NEW.id,
-						'record', NEW
-		)::text
-		);
+OldType
+    = "type" _ ":" _ type:OldTypeString {
+        return type; 
+    }
 
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
+OldTypeString
+    = text:"startsWith" { return function(column, value) { return \`\${column} ILIKE '\${format.literal(value).slice(1,-1)}%'\`; } }
+    / text:"endsWith"  { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}'\`; } }
+    / text:"contains" { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}%'\`; } }
+    / text:"exact" { return function(column, value)    { return \`\${column} = \${formatValue(value)}\`; } }
+    / text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= \${formatValue(value)}\`; } }
+    / text:"greaterThan" { return function(column, value) { return \`\${column} > \${formatValue(value)}\`; } }
+    / text:"lessThanEqual" { return function(column, value) { return \`\${column} <= \${formatValue(value)}\`; } }
+    / text:"lessThan" { return function(column, value) { return \`\${column} < \${formatValue(value)}\`; } }
+    / text:"isNull"   { return function(column, value) { return \`\${column} IS NULL\`; } }
 
-CREATE OR REPLACE TRIGGER "${tableName}_insert"
-	AFTER INSERT ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_insert();
+OldValue
+    = "value" _ ":" value:OldText {
+        return value; 
+    }
 `;
-  }
-  const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
-  return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
+var newGrammar = `
+StartNew
+    = ExpressionList
 
-	PERFORM pg_notify(
-		'insert',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'insertedId', NEW.id,
-						'record', json_build_object(
-							${notifyColumnNewBuildString}
-						)
-		)::text
-		);
+ExpressionList
+    = left:Expression _ op:("and"i / "or"i) _ right:ExpressionList
+        { return left + ' ' + op.toUpperCase() + ' ' + right; }
+    / Expression
 
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
+Expression
+    = negate:"!"? _ "(" _ inner:SimpleExprList _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + inner + ')'; }
+    / SimpleExpr
 
-CREATE OR REPLACE TRIGGER "${tableName}_insert"
-	AFTER INSERT ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_insert();
-`;
-}
-function createUpdateTriggerSql(tableName, notify) {
-  if (!notify) return "";
-  if (notify === "ALL") {
-    return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_update()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-				(regexp_match(
-						current_query(),
-						'^--QUERY_METADATA\\(({.*})', 'n'
-				))[1]::json;
+SimpleExprList
+    = left:SimpleExpr _ op:("and"i / "or"i) _ right:SimpleExprList
+        { return left + ' ' + op.toUpperCase() + ' ' + right; }
+    / SimpleExpr
 
-	PERFORM pg_notify(
-		'update',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'changedId', NEW.id,
-						'record', NEW,
-						'previousRecord', OLD
-		)::text
-		);
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
+SimpleExpr
+    = negate:"!"? _ "(" _ col:Column _ "," _ op:OperatorWithValue _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + op(col) + ')'; }
+    / negate:"!"? _ "(" _ col:Column _ "," _ op:NullOperator _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + op(col) + ')'; }
+    / negate:"!"? _ "(" _ col:Column _ "," _ val:CastedValue _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + formatColumn(col) + ' = ' + formatValueWithCast(val.value, val.cast) + ')'; }
 
-CREATE OR REPLACE TRIGGER ${tableName}_update
-	AFTER UPDATE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_update();
-`;
-  }
-  const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
-  const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
-  return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_update()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-				(regexp_match(
-						current_query(),
-						'^--QUERY_METADATA\\(({.*})', 'n'
-				))[1]::json;
+Column
+    = first:ColPart rest:("." ColPart)* cast:TypeCast? {
+        const partsArray = [first];
+        if (rest && rest.length > 0) {
+            partsArray.push(...rest.map(item => item[1]));
+        }
+        
+        if (partsArray.length > 3) {
+            throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
+        }
+        
+        var sql;
+        var isJsonField = false;
+        if (partsArray.length === 1) {
+            sql = quoteSqlIdentity(partsArray[0]);
+        } else {
+            const tableName = quoteSqlIdentity(partsArray[0]);
+            
+            if (partsArray.length === 2) {
+                sql = tableName + '.' + quoteSqlIdentity(partsArray[1]);
+            } else {
+                const jsonColumn = quoteSqlIdentity(partsArray[1]);
+                const lastPart = partsArray[partsArray.length - 1];
+                const escapedLast = lastPart.replace(/'/g, "''");
+                sql = tableName + '.' + jsonColumn + "->>'" + escapedLast + "'";
+                isJsonField = true;
+            }
+        }
+        
+        return { sql: sql, cast: cast, isJsonField: isJsonField };
+    }
 
-	PERFORM pg_notify(
-		'update',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'changedId', NEW.id,
-						'record', json_build_object(
-							${notifyColumnNewBuildString}
-						),
-						'previousRecord', json_build_object(
-							${notifyColumnOldBuildString}
-						)
-		)::text
-		);
-	RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
+ColPart
+    = chars:[a-zA-Z0-9_]+ { return chars.join(''); }
 
-CREATE OR REPLACE TRIGGER ${tableName}_update
-	AFTER UPDATE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_update();
-		`;
-}
-function createDeleteTriggerSql(tableName, notify) {
-  if (!notify) return "";
-  if (notify === "ALL") {
-    return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
+NullOperator
+    = "notnull"i { return function(col) { return formatColumn(col) + ' IS NOT NULL'; }; }
+    / "null"i { return function(col) { return formatColumn(col) + ' IS NULL'; }; }
+
+OperatorWithValue
+    = "in"i _ "," _ vals:InValueList cast:TypeCast? { return function(col) { 
+        var formattedCol = formatColumn(col);
+        var literals = vals.map(function(v) {
+            var unescaped = unescapeValue(v);
+            var formatted = formatValue(unescaped);
+            return cast ? formatted + '::' + cast : formatted;
+        });
+        return formattedCol + ' IN (' + literals.join(', ') + ')';
+    }; }
+    / "ne"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' <> ' + formatValueWithCast(val.value, val.cast); }; }
+    / "gte"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' >= ' + formatValueWithCast(val.value, val.cast); }; }
+    / "gt"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' > ' + formatValueWithCast(val.value, val.cast); }; }
+    / "lte"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' <= ' + formatValueWithCast(val.value, val.cast); }; }
+    / "lt"i _ "," _ val:CastedValue { return function(col) { return formatColumn(col) + ' < ' + formatValueWithCast(val.value, val.cast); }; }
+    / "has"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value) + '%'); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
+    / "sw"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal(unescapeValue(val.value) + '%'); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
+    / "ew"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value)); return formatColumn(col) + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
+
+InValueList
+    = first:InValue rest:("|" InValue)* {
+        var values = [first];
+        for (var i = 0; i < rest.length; i++) {
+            values.push(rest[i][1]);
+        }
+        return values;
+    }
+
+InValue
+    = QuotedString
+    / chars:InValueChar+ { return chars.join(''); }
+
+InValueChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" ]
+    / c:":" !":"  { return c; }
+
+CastedValue
+    = val:Value cast:TypeCast? { return { value: val, cast: cast }; }
+
+CastedValueWithPipes
+    = val:ValueWithPipes cast:TypeCast? { return { value: val, cast: cast }; }
+
+TypeCast
+    = "::" type:("timestamptz"i / "timestamp"i / "boolean"i / "numeric"i / "bigint"i / "text"i / "date"i / "int"i)
+        { return type.toLowerCase(); }
+
+QuotedString
+    = '"' chars:DoubleQuotedChar* '"' { return chars.join(''); }
+    / "'" chars:SingleQuotedChar* "'" { return chars.join(''); }
+
+DoubleQuotedChar
+    = '\\\\"' { return '"'; }
+    / '\\\\\\\\' { return '\\\\'; }
+    / [^"\\\\]
+
+SingleQuotedChar
+    = "\\\\'" { return "'"; }
+    / '\\\\\\\\' { return '\\\\'; }
+    / [^'\\\\]
+
+Value
+    = QuotedString
+    / chars:ValueChar+ { return chars.join(''); }
+
+ValueChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" ]
+    / c:":" !":"  { return c; }
 
-	PERFORM pg_notify(
-		'delete',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'deletedId', OLD.id,
-						'previousRecord', OLD
-		)::text
-		);
-	RETURN OLD;
-END;
-$$ LANGUAGE plpgsql;
+ValueWithPipes
+    = QuotedString
+    / chars:ValueWithPipesChar+ { return chars.join(''); }
 
-CREATE OR REPLACE TRIGGER "${tableName}_delete"
-	AFTER DELETE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_delete();
+ValueWithPipesChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [a-zA-Z0-9_\\-!#/@$%^&*+=<>?~.;'" |]
+    / c:":" !":"  { return c; }
 `;
-  }
-  const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
-  return `
-CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
-	RETURNS TRIGGER AS $$
-DECLARE
-	query_metadata JSON;
-BEGIN
-	SELECT INTO query_metadata
-			(regexp_match(
-					current_query(),
-					'^--QUERY_METADATA\\(({.*})', 'n'
-			))[1]::json;
-
-	PERFORM pg_notify(
-		'delete',
-		json_build_object(
-						'table', '${tableName}',
-						'queryMetadata', query_metadata,
-						'deletedId', OLD.id,
-						'previousRecord', json_build_object(
-							${notifyColumnOldBuildString}
-						)
-		)::text
-		);
-	RETURN OLD;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE TRIGGER "${tableName}_delete"
-	AFTER DELETE ON "${tableName}"
-	FOR EACH ROW
-EXECUTE FUNCTION notify_${tableName}_delete();
-		`;
-}
-function generateDatabaseSchemaFromSchema(schema) {
-  const sqlStatements = [];
-  const indexes = [];
-  const triggers = [];
-  for (const table of schema.database) {
-    if (table.notify) {
-      triggers.push(createInsertTriggerSql(table.name, table.notify));
-      triggers.push(createUpdateTriggerSql(table.name, table.notify));
-      triggers.push(createDeleteTriggerSql(table.name, table.notify));
-    }
-    let sql = `CREATE TABLE "${table.name}"
-				   ( `;
-    const tableColumns = [];
-    for (const column of table.columns) {
-      let columnSql = "";
-      columnSql += `	"${column.name}" ${schemaToPsqlType(column)}`;
-      let value = column.value;
-      if (column.type === "JSON") value = "";
-      if (column.type === "JSONB") value = "";
-      if (column.type === "DECIMAL" && value) {
-        value = value.replace("-", ",").replace(/['"]/g, "");
-      }
-      if (value && column.type !== "ENUM") {
-        columnSql += `(${value})`;
-      } else if (column.length) columnSql += `(${column.length})`;
-      if (column.isPrimary) {
-        columnSql += " PRIMARY KEY ";
-      }
-      if (column.isUnique) {
-        columnSql += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE `;
-      }
-      if (column.isNullable) columnSql += " NULL";
-      else columnSql += " NOT NULL";
-      if (column.default) columnSql += ` DEFAULT ${column.default}`;
-      if (value && column.type === "ENUM") {
-        columnSql += ` CHECK ("${column.name}" IN (${value}))`;
-      }
-      tableColumns.push(columnSql);
-    }
-    sql += tableColumns.join(", \n");
-    for (const index of table.indexes) {
-      if (!index.isPrimaryKey) {
-        let unique = " ";
-        if (index.isUnique) unique = "UNIQUE ";
-        let indexSQL = `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}"`;
-        indexSQL += ` (${index.columns.map((item) => `"${item}" ${index.order}`).join(", ")})`;
-        indexSQL += index.where ? ` WHERE ${index.where}` : "";
-        indexSQL += ";";
-        indexes.push(indexSQL);
-      }
-    }
-    sql += "\n);";
-    sqlStatements.push(sql);
-  }
-  for (const table of schema.database) {
-    if (!table.foreignKeys.length) continue;
-    const sql = `ALTER TABLE "${table.name}" `;
-    const constraints = [];
-    for (const foreignKey of table.foreignKeys) {
-      let constraint = `	 ADD CONSTRAINT "${foreignKey.name}"
-        FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}")`;
-      constraint += ` ON DELETE ${foreignKey.onDelete}`;
-      constraint += ` ON UPDATE ${foreignKey.onUpdate}`;
-      constraints.push(constraint);
-    }
-    sqlStatements.push(sql + constraints.join(",\n") + ";");
-  }
-  for (const table of schema.database) {
-    if (!table.checkConstraints.length) continue;
-    const sql = `ALTER TABLE "${table.name}" `;
-    const constraints = [];
-    for (const check of table.checkConstraints) {
-      const constraint = `ADD CONSTRAINT "${check.name}" CHECK (${check.check})`;
-      constraints.push(constraint);
-    }
-    sqlStatements.push(sql + constraints.join(",\n") + ";");
-  }
-  sqlStatements.push(indexes.join("\n"));
-  sqlStatements.push(triggers.join("\n"));
-  return sqlStatements.join("\n\n");
-}
-async function getNewPublicSchemaAndScratchPool(targetPool, scratchDbName) {
-  const scratchDbExists = await targetPool.runQuery(
-    `SELECT * FROM pg_database WHERE datname = ?;`,
-    [scratchDbName],
-    systemUser
-  );
-  if (scratchDbExists.length === 0) {
-    await targetPool.runQuery(`CREATE DATABASE ${escapeColumnName(scratchDbName)};`, [], systemUser);
-  }
-  const scratchPool = new PsqlPool({
-    host: targetPool.poolConfig.host,
-    port: targetPool.poolConfig.port,
-    user: targetPool.poolConfig.user,
-    database: scratchDbName,
-    password: targetPool.poolConfig.password,
-    max: targetPool.poolConfig.max,
-    idleTimeoutMillis: targetPool.poolConfig.idleTimeoutMillis,
-    connectionTimeoutMillis: targetPool.poolConfig.connectionTimeoutMillis
-  });
-  await scratchPool.runQuery(`DROP SCHEMA public CASCADE;`, [], systemUser);
-  await scratchPool.runQuery(
-    `CREATE SCHEMA public AUTHORIZATION ${escapeColumnName(targetPool.poolConfig.user)};`,
-    [],
-    systemUser
-  );
-  const schemaComment = await targetPool.runQuery(
-    `
-		SELECT pg_description.description
-		FROM pg_description
-		JOIN pg_namespace ON pg_namespace.oid = pg_description.objoid
-		WHERE pg_namespace.nspname = 'public';`,
-    [],
-    systemUser
-  );
-  if (schemaComment[0]?.description) {
-    const escaped = schemaComment[0].description.replace(/'/g, "''");
-    await scratchPool.runQuery(`COMMENT ON SCHEMA public IS '${escaped}';`, [], systemUser);
-  }
-  return scratchPool;
-}
-async function diffDatabaseToSchema(schema, targetPool, scratchDbName) {
-  let scratchPool;
-  let originalClient;
-  let scratchClient;
-  try {
-    scratchPool = await getNewPublicSchemaAndScratchPool(targetPool, scratchDbName);
-    const sqlFullStatement = generateDatabaseSchemaFromSchema(schema);
-    await scratchPool.runQuery(sqlFullStatement, [], systemUser);
-    const connectionConfig = {
-      host: targetPool.poolConfig.host,
-      port: targetPool.poolConfig.port,
-      user: targetPool.poolConfig.user,
-      password: targetPool.poolConfig.password,
-      ssl: targetPool.poolConfig.ssl
-    };
-    originalClient = new Client({ ...connectionConfig, database: targetPool.poolConfig.database });
-    scratchClient = new Client({ ...connectionConfig, database: scratchDbName });
-    await Promise.all([originalClient.connect(), scratchClient.connect()]);
-    const [info1, info2] = await Promise.all([
-      pgInfo({ client: originalClient }),
-      pgInfo({ client: scratchClient })
-    ]);
-    const diff = getDiff(info1, info2);
-    return diff.join("\n");
-  } finally {
-    const cleanups = [];
-    if (originalClient) cleanups.push(originalClient.end());
-    if (scratchClient) cleanups.push(scratchClient.end());
-    if (scratchPool) cleanups.push(scratchPool.pool.end());
-    await Promise.allSettled(cleanups);
-  }
-}
+var fullGrammar = entryGrammar + oldGrammar + newGrammar;
+var filterPsqlParser = peg.generate(fullGrammar, {
+  format: "commonjs",
+  dependencies: { format: "pg-format" }
+});
+var filterPsqlParser_default = filterPsqlParser;
 
 // src/restura/sql/PsqlEngine.ts
-var { Client: Client2, types } = pg3;
+var { Client: Client3, types } = pg4;
 var PsqlEngine = class extends SqlEngine {
-  // 5 seconds
-  constructor(psqlConnectionPool, shouldListenForDbTriggers = false, scratchDatabaseSuffix = "") {
+  constructor(psqlConnectionPool, shouldListenForDbTriggers = false, scratchDatabaseSuffix = "", eventDelivery) {
     super();
     this.psqlConnectionPool = psqlConnectionPool;
+    this.eventDelivery = eventDelivery || { mode: "direct" };
     this.setupPgReturnTypes();
+    if (this.eventDelivery.mode === "outbox") {
+      this.outboxConsumer = new EventOutboxConsumer(psqlConnectionPool, this.eventDelivery.outbox);
+    }
     if (shouldListenForDbTriggers) {
-      this.setupTriggerListeners = this.listenForDbTriggers();
+      this.setupTriggerListeners = this.listenForDbTriggers().catch((error) => {
+        logger.error(`Failed to setup trigger listeners: ${error}`);
+        void this.reconnectTriggerClient();
+      });
+      this.outboxConsumer?.start();
     }
     this.scratchDbName = `${psqlConnectionPool.poolConfig.database}_scratch${scratchDatabaseSuffix ? `_${scratchDatabaseSuffix}` : ""}`;
   }
@@ -2931,12 +3176,34 @@ var PsqlEngine = class extends SqlEngine {
   triggerClient;
   scratchDbName = "";
   reconnectAttempts = 0;
-  MAX_RECONNECT_ATTEMPTS = 5;
   INITIAL_RECONNECT_DELAY = 5e3;
+  MAX_RECONNECT_DELAY = 6e4;
+  HEARTBEAT_INTERVAL_MS = 3e4;
+  eventDelivery;
+  outboxConsumer;
+  heartbeatTimer;
+  isListenerConnected = false;
+  isReconnecting = false;
+  isClosed = false;
+  lastHeartbeatOn = null;
   async close() {
+    this.isClosed = true;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.outboxConsumer) await this.outboxConsumer.stop();
     if (this.triggerClient) {
       await this.triggerClient.end();
     }
+    this.isListenerConnected = false;
+  }
+  getEventListenerHealth() {
+    return {
+      connected: this.isListenerConnected,
+      lastHeartbeatOn: this.lastHeartbeatOn,
+      reconnectAttempts: this.reconnectAttempts
+    };
+  }
+  getOutboxConsumer() {
+    return this.outboxConsumer;
   }
   /**
    * Setup the return types for the PostgreSQL connection.
@@ -2959,35 +3226,55 @@ var PsqlEngine = class extends SqlEngine {
     types.setTypeParser(PG_TYPE_OID.TIMESTAMPTZ, (val) => val === null ? null : new Date(val).toISOString());
   }
   async reconnectTriggerClient() {
-    if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
-      logger.error("Max reconnection attempts reached for trigger client. Stopping reconnection attempts.");
-      return;
+    if (this.isReconnecting || this.isClosed) return;
+    this.isReconnecting = true;
+    this.isListenerConnected = false;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    try {
+      while (!this.isClosed) {
+        if (this.triggerClient) {
+          try {
+            await this.triggerClient.end();
+          } catch (error) {
+            logger.error(`Error closing trigger client: ${error}`);
+          }
+          this.triggerClient = void 0;
+        }
+        const exponentialDelay = this.INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts);
+        const delay = Math.min(exponentialDelay, this.MAX_RECONNECT_DELAY) + Math.floor(Math.random() * 1e3);
+        logger.info(
+          `Attempting to reconnect trigger client in ${Math.round(delay / 1e3)} seconds... (attempt ${this.reconnectAttempts + 1})`
+        );
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        if (this.isClosed) return;
+        this.reconnectAttempts++;
+        try {
+          await this.listenForDbTriggers();
+          this.reconnectAttempts = 0;
+          return;
+        } catch (error) {
+          logger.error(`Reconnection attempt ${this.reconnectAttempts} failed: ${error}`);
+        }
+      }
+    } finally {
+      this.isReconnecting = false;
     }
-    if (this.triggerClient) {
+  }
+  startHeartbeat() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = setInterval(async () => {
+      if (!this.triggerClient || this.isClosed) return;
       try {
-        await this.triggerClient.end();
+        await this.triggerClient.query("SELECT 1");
+        this.lastHeartbeatOn = (/* @__PURE__ */ new Date()).toISOString();
       } catch (error) {
-        logger.error(`Error closing trigger client: ${error}`);
-      }
-    }
-    const delay = this.INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts);
-    logger.info(
-      `Attempting to reconnect trigger client in ${delay / 1e3} seconds... (Attempt ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS})`
-    );
-    await new Promise((resolve2) => setTimeout(resolve2, delay));
-    this.reconnectAttempts++;
-    try {
-      await this.listenForDbTriggers();
-      this.reconnectAttempts = 0;
-    } catch (error) {
-      logger.error(`Reconnection attempt ${this.reconnectAttempts} failed: ${error}`);
-      if (this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
-        await this.reconnectTriggerClient();
+        logger.error(`Trigger client heartbeat failed, reconnecting: ${error}`);
+        void this.reconnectTriggerClient();
       }
-    }
+    }, this.HEARTBEAT_INTERVAL_MS);
   }
   async listenForDbTriggers() {
-    this.triggerClient = new Client2({
+    const client = new Client3({
       user: this.psqlConnectionPool.poolConfig.user,
       host: this.psqlConnectionPool.poolConfig.host,
       database: this.psqlConnectionPool.poolConfig.database,
@@ -2995,25 +3282,52 @@ var PsqlEngine = class extends SqlEngine {
       port: this.psqlConnectionPool.poolConfig.port,
       connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
     });
+    this.triggerClient = client;
+    client.on("error", (error) => {
+      logger.error(`Trigger client error: ${error}`);
+      void this.reconnectTriggerClient();
+    });
+    client.on("notification", async (msg) => {
+      if (this.outboxConsumer && msg.channel === this.outboxConsumer.channel) {
+        await this.outboxConsumer.drain();
+      } else if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
+        const payload = ObjectUtils3.safeParse(msg.payload);
+        await this.handleTrigger(payload, msg.channel.toUpperCase());
+      }
+    });
+    await client.connect();
+    const channels = ["insert", "update", "delete"];
+    if (this.outboxConsumer) channels.push(this.outboxConsumer.channel);
+    for (const channel of channels) {
+      await client.query(`LISTEN ${escapeColumnName(channel)}`);
+    }
+    this.isListenerConnected = true;
+    this.lastHeartbeatOn = (/* @__PURE__ */ new Date()).toISOString();
+    this.startHeartbeat();
+    logger.info("Successfully connected to database triggers");
+    void this.warnIfOutboxBacklogInDirectMode();
+  }
+  async warnIfOutboxBacklogInDirectMode() {
+    if (this.eventDelivery.mode !== "direct") return;
     try {
-      await this.triggerClient.connect();
-      for (const channel of ["insert", "update", "delete"]) {
-        await this.triggerClient.query(`LISTEN ${channel}`);
+      const tableExists = await this.psqlConnectionPool.runQuery(
+        `SELECT to_regclass('public."dbEventOutbox"') AS exists;`,
+        [],
+        systemUser
+      );
+      if (!tableExists[0]?.exists) return;
+      const pending = await this.psqlConnectionPool.runQuery(
+        `SELECT COUNT(*)::int AS count FROM "dbEventOutbox" WHERE "processedOn" IS NULL;`,
+        [],
+        systemUser
+      );
+      if (Number(pending[0]?.count) > 0) {
+        logger.warn(
+          `eventDelivery is 'direct' but "dbEventOutbox" exists with ${pending[0].count} unprocessed rows \u2014 the database appears to have outbox-mode triggers installed. Switch eventDelivery to 'outbox' or regenerate direct-mode triggers.`
+        );
       }
-      this.triggerClient.on("error", async (error) => {
-        logger.error(`Trigger client error: ${error}`);
-        await this.reconnectTriggerClient();
-      });
-      this.triggerClient.on("notification", async (msg) => {
-        if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
-          const payload = ObjectUtils3.safeParse(msg.payload);
-          await this.handleTrigger(payload, msg.channel.toUpperCase());
-        }
-      });
-      logger.info("Successfully connected to database triggers");
     } catch (error) {
-      logger.error(`Failed to setup trigger listeners: ${error}`);
-      await this.reconnectTriggerClient();
+      logger.warn(`Could not check dbEventOutbox backlog: ${error}`);
     }
   }
   async handleTrigger(payload, mutationType) {
@@ -3027,10 +3341,21 @@ var PsqlEngine = class extends SqlEngine {
     return sqlFullStatement;
   }
   generateDatabaseSchemaFromSchema(schema) {
-    return generateDatabaseSchemaFromSchema(schema);
+    return generateDatabaseSchemaFromSchema(schema, this.schemaGenerationOptions());
   }
   async diffDatabaseToSchema(schema) {
-    return diffDatabaseToSchema(schema, this.psqlConnectionPool, this.scratchDbName);
+    return diffDatabaseToSchema(
+      schema,
+      this.psqlConnectionPool,
+      this.scratchDbName,
+      this.schemaGenerationOptions()
+    );
+  }
+  schemaGenerationOptions() {
+    return {
+      eventDelivery: this.eventDelivery.mode,
+      outboxChannel: this.eventDelivery.outbox?.channel
+    };
   }
   createNestedSelect(req, schema, item, routeData, sqlParams) {
     if (!item.subquery) return "";
@@ -3468,7 +3793,13 @@ var ResturaEngine = class {
     this.multerCommonUpload = getMulterUpload(this.resturaConfig.fileTempCachePath);
     new TempCache(this.resturaConfig.fileTempCachePath);
     this.psqlConnectionPool = psqlConnectionPool;
-    this.psqlEngine = new PsqlEngine(this.psqlConnectionPool, true, this.resturaConfig.scratchDatabaseSuffix);
+    if (this.resturaConfig.queryMetadataKeys) {
+      PsqlConnection.setQueryMetadataKeys(this.resturaConfig.queryMetadataKeys);
+    }
+    this.psqlEngine = new PsqlEngine(this.psqlConnectionPool, true, this.resturaConfig.scratchDatabaseSuffix, {
+      mode: this.resturaConfig.eventDelivery,
+      outbox: this.resturaConfig.eventOutbox
+    });
     await customApiFactory_default.loadApiFiles(this.resturaConfig.customApiFolderPath);
     this.authenticationHandler = authenticationHandler;
     app.use(compression());
@@ -3494,6 +3825,7 @@ var ResturaEngine = class {
     this.expressApp = app;
     await this.reloadEndpoints();
     await this.initializeGeneratedTypesFolder();
+    eventManager_default.validateHandlersAgainstSchema(this.schema, this.resturaConfig.notifyValidation);
     logger.info("Restura Engine Initialized");
   }
   /**
@@ -3623,6 +3955,7 @@ var ResturaEngine = class {
   }
   async updateSchema(req, res) {
     try {
+      eventManager_default.validateHandlersAgainstSchema(req.data, this.resturaConfig.notifyValidation);
       this.schema = sortObjectKeysAlphabetically(req.data);
       await this.storeFileSystemSchema();
       await this.reloadEndpoints();
@@ -4431,47 +4764,12 @@ function defaultsMatch(desired, live, column) {
   const normalizedLive = live.replace(/::[a-z][a-z0-9_ ]*(\[\])?$/gi, "").trim();
   return lowercaseOutsideStrings(desired.trim()) === lowercaseOutsideStrings(normalizedLive);
 }
-
-// src/restura/sql/PsqlTransaction.ts
-import pg4 from "pg";
-var { Client: Client3 } = pg4;
-var PsqlTransaction = class extends PsqlConnection {
-  constructor(clientConfig, instanceId) {
-    super(instanceId);
-    this.clientConfig = clientConfig;
-    this.client = new Client3(clientConfig);
-    this.connectPromise = this.client.connect();
-    this.beginTransactionPromise = this.beginTransaction();
-  }
-  client;
-  beginTransactionPromise;
-  connectPromise;
-  async close() {
-    if (this.client) {
-      await this.client.end();
-    }
-  }
-  async beginTransaction() {
-    await this.connectPromise;
-    return this.client.query("BEGIN");
-  }
-  async rollback() {
-    return this.query("ROLLBACK");
-  }
-  async commit() {
-    return this.query("COMMIT");
-  }
-  async release() {
-    return this.client.end();
-  }
-  async query(query, values) {
-    await this.connectPromise;
-    await this.beginTransactionPromise;
-    return this.client.query(query, values);
-  }
-};
 export {
+  DEFAULT_OUTBOX_CHANNEL,
+  EventManager,
+  EventOutboxConsumer,
   HtmlStatusCodes,
+  OUTBOX_TABLE_NAME,
   PsqlConnection,
   PsqlEngine,
   PsqlPool,
@@ -4481,17 +4779,21 @@ export {
   apiGenerator,
   createDeleteTriggerSql,
   createInsertTriggerSql,
+  createOutboxTableSql,
   createUpdateTriggerSql,
+  defaultEventOutboxOptions,
   diffDatabaseToSchema,
   diffSchemaToDatabase,
   escapeColumnName,
   eventManager_default as eventManager,
   filterPsqlParser_default as filterPsqlParser,
   generateDatabaseSchemaFromSchema,
+  generateNotifyTriggersSql,
   getNewPublicSchemaAndScratchPool,
   insertObjectQuery,
   introspectDatabase,
   isSchemaValid,
+  isSensitiveColumnName,
   isValueNumber,
   logger,
   modelGenerator,