@restura/core 0.1.0-alpha.15 → 0.1.0-alpha.17

package/dist/index.d.mts

@@ -1392,10 +1392,10 @@ interface AsyncExpressApplication {
 }
 
 declare abstract class PsqlConnection {
-    constructor();
+    protected constructor();
     protected abstract query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
-    queryOne(query: string, options: any[], requesterDetails: RequesterDetails): Promise<QueryResultRow>;
-    runQuery(query: string, options: any[], requesterDetails: RequesterDetails): Promise<QueryResultRow[]>;
+    queryOne<T>(query: string, options: any[], requesterDetails: RequesterDetails): Promise<T>;
+    runQuery<T>(query: string, options: any[], requesterDetails: RequesterDetails): Promise<T[]>;
     private logSqlStatement;
 }
 
@@ -1406,18 +1406,6 @@ declare class PsqlPool extends PsqlConnection {
     protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
 }
 
-declare class PsqlTransaction extends PsqlConnection {
-    clientConfig: ClientConfig;
-    client: Client;
-    private beginTransactionPromise;
-    constructor(clientConfig: ClientConfig);
-    private beginTransaction;
-    rollback(): Promise<QueryResult<QueryResultRow>>;
-    commit(): Promise<QueryResult<QueryResultRow>>;
-    release(): Promise<void>;
-    protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
-}
-
 declare class ResturaEngine {
     resturaConfig: ResturaConfigSchema;
     private resturaRouter;
@@ -1516,4 +1504,69 @@ declare function updateObjectQuery(table: string, obj: DynamicObject, whereState
 declare function isValueNumber(value: unknown): value is number;
 declare function SQL(strings: any, ...values: any): any;
 
-export { type ApiMethod, type AsyncExpressApplication, type AuthenticateHandler, type AuthenticationUserDetails, type ConjunctionTypes, type DynamicObject, type ErrorCode, HtmlStatusCodes, type LoginDetails, type MatchTypes, type PageQuery, PsqlConnection, PsqlPool, PsqlTransaction, type RequesterDetails, type ResponseType, type ResponseTypeMap, RsError, type RsErrorData, type RsErrorInternalData, type RsHeaders, type RsPagedResponseData, type RsRequest, type RsResponse, type RsResponseData, type RsRouteHandler, SQL, type SchemaChangeValue, type SchemaPreview, type StandardOrderTypes, type ValidAuthenticationCallback, type ValidatorString, escapeColumnName, insertObjectQuery, isValueNumber, logger, questionMarksToOrderedParams, restura, updateObjectQuery };
+declare class PsqlTransaction extends PsqlConnection {
+    clientConfig: ClientConfig;
+    client: Client;
+    private beginTransactionPromise;
+    constructor(clientConfig: ClientConfig);
+    private beginTransaction;
+    rollback(): Promise<QueryResult<QueryResultRow>>;
+    commit(): Promise<QueryResult<QueryResultRow>>;
+    release(): Promise<void>;
+    protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
+}
+
+type EventType = 'DATABASE_ROW_DELETE' | 'DATABASE_ROW_INSERT' | 'DATABASE_COLUMN_UPDATE' | 'WEBHOOK';
+type MutationType = 'INSERT' | 'UPDATE' | 'DELETE';
+interface SqlMutationData {
+    mutationType: MutationType;
+    requesterDetails: RequesterDetails;
+}
+interface DatabaseActionData {
+    tableName: string;
+    requesterDetails: RequesterDetails;
+}
+interface ActionRowInsertData<T = DynamicObject> extends DatabaseActionData {
+    insertId: number;
+    insertObject: T;
+}
+interface ActionRowDeleteData extends DatabaseActionData {
+    deletedRow: DynamicObject;
+}
+interface ActionColumnChangeData extends DatabaseActionData {
+    tableName: string;
+    rowId: number;
+    newData: DynamicObject;
+    oldData: DynamicObject;
+}
+interface ActionRowInsertFilter {
+    tableName: string;
+}
+interface ActionRowDeleteFilter {
+    tableName: string;
+}
+interface ActionColumnChangeFilter {
+    tableName: string;
+}
+type TriggerResult = {
+    table: string;
+    insertId?: number;
+    query: string;
+    record: DynamicObject;
+    previousRecord: DynamicObject;
+    requesterId: number;
+};
+declare class EventManager {
+    private actionHandlers;
+    addRowInsertHandler(onInsert: (data: ActionRowInsertData<unknown>) => Promise<void>, filter?: ActionRowInsertFilter): void;
+    addColumnChangeHandler(onUpdate: (data: ActionColumnChangeData) => Promise<void>, filter: ActionColumnChangeFilter): void;
+    addRowDeleteHandler(onDelete: (data: ActionRowDeleteData) => Promise<void>, filter?: ActionRowDeleteFilter): void;
+    fireActionFromDbTrigger(sqlMutationData: SqlMutationData, result: TriggerResult): Promise<void>;
+    private fireInsertActions;
+    private fireDeleteActions;
+    private fireUpdateActions;
+    private hasHandlersForEventType;
+}
+declare const eventManager: EventManager;
+
+export { type ActionColumnChangeData, type ActionColumnChangeFilter, type ActionRowDeleteData, type ActionRowDeleteFilter, type ActionRowInsertData, type ActionRowInsertFilter, type ApiMethod, type AsyncExpressApplication, type AuthenticateHandler, type AuthenticationUserDetails, type ConjunctionTypes, type DatabaseActionData, type DynamicObject, type ErrorCode, type EventType, HtmlStatusCodes, type LoginDetails, type MatchTypes, type MutationType, type PageQuery, PsqlConnection, PsqlPool, PsqlTransaction, type RequesterDetails, type ResponseType, type ResponseTypeMap, RsError, type RsErrorData, type RsErrorInternalData, type RsHeaders, type RsPagedResponseData, type RsRequest, type RsResponse, type RsResponseData, type RsRouteHandler, SQL, type SchemaChangeValue, type SchemaPreview, type SqlMutationData, type StandardOrderTypes, type TriggerResult, type ValidAuthenticationCallback, type ValidatorString, escapeColumnName, eventManager, insertObjectQuery, isValueNumber, logger, questionMarksToOrderedParams, restura, updateObjectQuery };

package/dist/index.d.ts

@@ -1392,10 +1392,10 @@ interface AsyncExpressApplication {
 }
 
 declare abstract class PsqlConnection {
-    constructor();
+    protected constructor();
     protected abstract query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
-    queryOne(query: string, options: any[], requesterDetails: RequesterDetails): Promise<QueryResultRow>;
-    runQuery(query: string, options: any[], requesterDetails: RequesterDetails): Promise<QueryResultRow[]>;
+    queryOne<T>(query: string, options: any[], requesterDetails: RequesterDetails): Promise<T>;
+    runQuery<T>(query: string, options: any[], requesterDetails: RequesterDetails): Promise<T[]>;
     private logSqlStatement;
 }
 
@@ -1406,18 +1406,6 @@ declare class PsqlPool extends PsqlConnection {
     protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
 }
 
-declare class PsqlTransaction extends PsqlConnection {
-    clientConfig: ClientConfig;
-    client: Client;
-    private beginTransactionPromise;
-    constructor(clientConfig: ClientConfig);
-    private beginTransaction;
-    rollback(): Promise<QueryResult<QueryResultRow>>;
-    commit(): Promise<QueryResult<QueryResultRow>>;
-    release(): Promise<void>;
-    protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
-}
-
 declare class ResturaEngine {
     resturaConfig: ResturaConfigSchema;
     private resturaRouter;
@@ -1516,4 +1504,69 @@ declare function updateObjectQuery(table: string, obj: DynamicObject, whereState
 declare function isValueNumber(value: unknown): value is number;
 declare function SQL(strings: any, ...values: any): any;
 
-export { type ApiMethod, type AsyncExpressApplication, type AuthenticateHandler, type AuthenticationUserDetails, type ConjunctionTypes, type DynamicObject, type ErrorCode, HtmlStatusCodes, type LoginDetails, type MatchTypes, type PageQuery, PsqlConnection, PsqlPool, PsqlTransaction, type RequesterDetails, type ResponseType, type ResponseTypeMap, RsError, type RsErrorData, type RsErrorInternalData, type RsHeaders, type RsPagedResponseData, type RsRequest, type RsResponse, type RsResponseData, type RsRouteHandler, SQL, type SchemaChangeValue, type SchemaPreview, type StandardOrderTypes, type ValidAuthenticationCallback, type ValidatorString, escapeColumnName, insertObjectQuery, isValueNumber, logger, questionMarksToOrderedParams, restura, updateObjectQuery };
+declare class PsqlTransaction extends PsqlConnection {
+    clientConfig: ClientConfig;
+    client: Client;
+    private beginTransactionPromise;
+    constructor(clientConfig: ClientConfig);
+    private beginTransaction;
+    rollback(): Promise<QueryResult<QueryResultRow>>;
+    commit(): Promise<QueryResult<QueryResultRow>>;
+    release(): Promise<void>;
+    protected query<R extends QueryResultRow = QueryResultRow, T extends Array<unknown> = unknown[]>(query: string, values?: QueryConfigValues<T>): Promise<QueryResult<R>>;
+}
+
+type EventType = 'DATABASE_ROW_DELETE' | 'DATABASE_ROW_INSERT' | 'DATABASE_COLUMN_UPDATE' | 'WEBHOOK';
+type MutationType = 'INSERT' | 'UPDATE' | 'DELETE';
+interface SqlMutationData {
+    mutationType: MutationType;
+    requesterDetails: RequesterDetails;
+}
+interface DatabaseActionData {
+    tableName: string;
+    requesterDetails: RequesterDetails;
+}
+interface ActionRowInsertData<T = DynamicObject> extends DatabaseActionData {
+    insertId: number;
+    insertObject: T;
+}
+interface ActionRowDeleteData extends DatabaseActionData {
+    deletedRow: DynamicObject;
+}
+interface ActionColumnChangeData extends DatabaseActionData {
+    tableName: string;
+    rowId: number;
+    newData: DynamicObject;
+    oldData: DynamicObject;
+}
+interface ActionRowInsertFilter {
+    tableName: string;
+}
+interface ActionRowDeleteFilter {
+    tableName: string;
+}
+interface ActionColumnChangeFilter {
+    tableName: string;
+}
+type TriggerResult = {
+    table: string;
+    insertId?: number;
+    query: string;
+    record: DynamicObject;
+    previousRecord: DynamicObject;
+    requesterId: number;
+};
+declare class EventManager {
+    private actionHandlers;
+    addRowInsertHandler(onInsert: (data: ActionRowInsertData<unknown>) => Promise<void>, filter?: ActionRowInsertFilter): void;
+    addColumnChangeHandler(onUpdate: (data: ActionColumnChangeData) => Promise<void>, filter: ActionColumnChangeFilter): void;
+    addRowDeleteHandler(onDelete: (data: ActionRowDeleteData) => Promise<void>, filter?: ActionRowDeleteFilter): void;
+    fireActionFromDbTrigger(sqlMutationData: SqlMutationData, result: TriggerResult): Promise<void>;
+    private fireInsertActions;
+    private fireDeleteActions;
+    private fireUpdateActions;
+    private hasHandlersForEventType;
+}
+declare const eventManager: EventManager;
+
+export { type ActionColumnChangeData, type ActionColumnChangeFilter, type ActionRowDeleteData, type ActionRowDeleteFilter, type ActionRowInsertData, type ActionRowInsertFilter, type ApiMethod, type AsyncExpressApplication, type AuthenticateHandler, type AuthenticationUserDetails, type ConjunctionTypes, type DatabaseActionData, type DynamicObject, type ErrorCode, type EventType, HtmlStatusCodes, type LoginDetails, type MatchTypes, type MutationType, type PageQuery, PsqlConnection, PsqlPool, PsqlTransaction, type RequesterDetails, type ResponseType, type ResponseTypeMap, RsError, type RsErrorData, type RsErrorInternalData, type RsHeaders, type RsPagedResponseData, type RsRequest, type RsResponse, type RsResponseData, type RsRouteHandler, SQL, type SchemaChangeValue, type SchemaPreview, type SqlMutationData, type StandardOrderTypes, type TriggerResult, type ValidAuthenticationCallback, type ValidatorString, escapeColumnName, eventManager, insertObjectQuery, isValueNumber, logger, questionMarksToOrderedParams, restura, updateObjectQuery };

package/dist/index.js

@@ -74,6 +74,7 @@ __export(src_exports, {
   RsError: () => RsError,
   SQL: () => SQL,
   escapeColumnName: () => escapeColumnName,
+  eventManager: () => eventManager_default,
   insertObjectQuery: () => insertObjectQuery,
   isValueNumber: () => isValueNumber2,
   logger: () => logger,
@@ -260,7 +261,7 @@ var import_crypto = require("crypto");
 var express = __toESM(require("express"));
 var import_fs3 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
-var import_pg4 = __toESM(require("pg"));
+var import_pg3 = __toESM(require("pg"));
 var prettier3 = __toESM(require("prettier"));
 
 // src/restura/sql/SqlUtils.ts
@@ -1279,7 +1280,8 @@ function insertObjectQuery(table, obj) {
   const params = Object.values(obj);
   const columns = keys.map((column) => escapeColumnName(column)).join(", ");
   const values = params.map((value) => SQL`${value}`).join(", ");
-  const query = `INSERT INTO "${table}" (${columns})
+  const query = `
+INSERT INTO "${table}" (${columns})
                  VALUES (${values})
                  RETURNING *`;
   return query;
@@ -1289,7 +1291,8 @@ function updateObjectQuery(table, obj, whereStatement) {
   for (const i in obj) {
     setArray.push(`${escapeColumnName(i)} = ` + SQL`${obj[i]}`);
   }
-  return `UPDATE ${escapeColumnName(table)}
+  return `
+UPDATE ${escapeColumnName(table)}
                  SET ${setArray.join(", ")} ${whereStatement}
                  RETURNING *`;
 }
@@ -1319,8 +1322,10 @@ var PsqlConnection = class {
   async queryOne(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     this.logSqlStatement(formattedQuery, options, requesterDetails);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(requesterDetails)})
+`;
     try {
-      const response = await this.query(formattedQuery, options);
+      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");
       return response.rows[0];
@@ -1337,8 +1342,10 @@ var PsqlConnection = class {
   async runQuery(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     this.logSqlStatement(formattedQuery, options, requesterDetails);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(requesterDetails)})
+`;
     try {
-      const response = await this.query(formattedQuery, options);
+      const response = await this.query(queryMetadata + formattedQuery, options);
       return response.rows;
     } catch (error) {
       console.error(error, query, options);
@@ -1589,6 +1596,110 @@ var filterPsqlParser = import_pegjs.default.generate(filterSqlGrammar, {
 });
 var filterPsqlParser_default = filterPsqlParser;
 
+// src/restura/eventManager.ts
+var import_bluebird = __toESM(require("bluebird"));
+var EventManager = class {
+  constructor() {
+    this.actionHandlers = {
+      DATABASE_ROW_DELETE: [],
+      DATABASE_ROW_INSERT: [],
+      DATABASE_COLUMN_UPDATE: []
+    };
+  }
+  addRowInsertHandler(onInsert, filter) {
+    this.actionHandlers.DATABASE_ROW_INSERT.push({
+      callback: onInsert,
+      filter
+    });
+  }
+  addColumnChangeHandler(onUpdate, filter) {
+    this.actionHandlers.DATABASE_COLUMN_UPDATE.push({
+      callback: onUpdate,
+      filter
+    });
+  }
+  addRowDeleteHandler(onDelete, filter) {
+    this.actionHandlers.DATABASE_ROW_DELETE.push({
+      callback: onDelete,
+      filter
+    });
+  }
+  async fireActionFromDbTrigger(sqlMutationData, result) {
+    if (sqlMutationData.mutationType === "INSERT") {
+      await this.fireInsertActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "UPDATE") {
+      await this.fireUpdateActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "DELETE") {
+      await this.fireDeleteActions(sqlMutationData, result);
+    }
+  }
+  async fireInsertActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_ROW_INSERT,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
+        const insertData = {
+          tableName: triggerResult.table,
+          insertId: triggerResult.record.id,
+          insertObject: triggerResult.record,
+          requesterDetails: data.requesterDetails
+        };
+        callback(insertData, data.requesterDetails);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireDeleteActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_ROW_DELETE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
+        const deleteData = {
+          tableName: triggerResult.table,
+          deletedRow: triggerResult.previousRecord,
+          requesterDetails: data.requesterDetails
+        };
+        callback(deleteData, data.requesterDetails);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireUpdateActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_COLUMN_UPDATE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
+        const columnChangeData = {
+          tableName: triggerResult.table,
+          rowId: triggerResult.record.id,
+          newData: triggerResult.record,
+          oldData: triggerResult.previousRecord,
+          requesterDetails: data.requesterDetails
+        };
+        callback(columnChangeData, data.requesterDetails);
+      },
+      { concurrency: 10 }
+    );
+  }
+  hasHandlersForEventType(eventType, filter, triggerResult) {
+    if (filter) {
+      switch (eventType) {
+        case "DATABASE_ROW_INSERT":
+        case "DATABASE_ROW_DELETE":
+          if (filter.tableName && filter.tableName !== triggerResult.table) return false;
+          break;
+        case "DATABASE_COLUMN_UPDATE":
+          const filterColumnChange = filter;
+          if (filterColumnChange.tableName !== filter.tableName) return false;
+          break;
+      }
+    }
+    return true;
+  }
+};
+var eventManager = new EventManager();
+var eventManager_default = eventManager;
+
 // src/restura/sql/PsqlEngine.ts
 var { Client } = import_pg2.default;
 var systemUser = {
@@ -1598,9 +1709,49 @@ var systemUser = {
   isSystemUser: true
 };
 var PsqlEngine = class extends SqlEngine {
-  constructor(psqlConnectionPool) {
+  constructor(psqlConnectionPool, shouldListenForDbTriggers = false) {
     super();
     this.psqlConnectionPool = psqlConnectionPool;
+    if (shouldListenForDbTriggers) {
+      this.setupTriggerListeners = this.listenForDbTriggers();
+    }
+  }
+  async close() {
+    if (this.triggerClient) {
+      await this.triggerClient.end();
+    }
+  }
+  async listenForDbTriggers() {
+    this.triggerClient = new Client({
+      user: this.psqlConnectionPool.poolConfig.user,
+      host: this.psqlConnectionPool.poolConfig.host,
+      database: this.psqlConnectionPool.poolConfig.database,
+      password: this.psqlConnectionPool.poolConfig.password,
+      port: this.psqlConnectionPool.poolConfig.port,
+      connectionTimeoutMillis: 2e3
+    });
+    await this.triggerClient.connect();
+    const promises = [];
+    promises.push(this.triggerClient.query("LISTEN insert"));
+    promises.push(this.triggerClient.query("LISTEN update"));
+    promises.push(this.triggerClient.query("LISTEN delete"));
+    await Promise.all(promises);
+    this.triggerClient.on("notification", async (msg) => {
+      if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
+        const payload = JSON.parse(msg.payload);
+        await this.handleTrigger(payload, msg.channel.toUpperCase());
+      }
+    });
+  }
+  async handleTrigger(payload, mutationType) {
+    const findRequesterDetailsRegex = /^--QUERY_METADATA\(\{.*\}\)/;
+    let requesterDetails = {};
+    const match = payload.query.match(findRequesterDetailsRegex);
+    if (match) {
+      const jsonString = match[0].slice(match[0].indexOf("{"), match[0].lastIndexOf("}") + 1);
+      requesterDetails = import_core_utils5.ObjectUtils.safeParse(jsonString);
+      await eventManager_default.fireActionFromDbTrigger({ requesterDetails, mutationType }, payload);
+    }
   }
   async createDatabaseFromSchema(schema, connection) {
     const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
@@ -1611,7 +1762,11 @@ var PsqlEngine = class extends SqlEngine {
     const sqlStatements = [];
     const enums = [];
     const indexes = [];
+    const triggers = [];
     for (const table of schema.database) {
+      triggers.push(this.createInsertTriggers(table.name));
+      triggers.push(this.createUpdateTrigger(table.name));
+      triggers.push(this.createDeleteTrigger(table.name));
       let sql = `CREATE TABLE "${table.name}"
 					   ( `;
       const tableColumns = [];
@@ -1649,7 +1804,7 @@ var PsqlEngine = class extends SqlEngine {
           indexes.push(
             `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}" (${index.columns.map((item) => {
               return `"${item}" ${index.order}`;
-            }).join(", ")})`
+            }).join(", ")});`
           );
         }
       }
@@ -1679,7 +1834,8 @@ var PsqlEngine = class extends SqlEngine {
       }
       sqlStatements.push(sql + constraints.join(",\n") + ";");
     }
-    sqlStatements.push(indexes.join(";\n"));
+    sqlStatements.push(indexes.join("\n"));
+    sqlStatements.push(triggers.join("\n"));
     return enums.join("\n") + "\n" + sqlStatements.join("\n\n");
   }
   async getScratchPool() {
@@ -1747,8 +1903,7 @@ var PsqlEngine = class extends SqlEngine {
     )) {
       return "'[]'";
     }
-    return `COALESCE((
-				SELECT JSON_AGG(JSON_BUILD_OBJECT(
+    return `COALESCE((SELECT JSON_AGG(JSON_BUILD_OBJECT(
 			${item.subquery.properties.map((nestedItem) => {
       if (!this.doesRoleHavePermissionToColumn(req.requesterDetails.role, schema, nestedItem, [
         ...routeData.joins,
@@ -1757,7 +1912,7 @@ var PsqlEngine = class extends SqlEngine {
         return;
       }
       if (nestedItem.subquery) {
-        return `"${nestedItem.name}", ${this.createNestedSelect(
+        return `'${nestedItem.name}', ${this.createNestedSelect(
           // recursion
           req,
           schema,
@@ -1768,7 +1923,7 @@ var PsqlEngine = class extends SqlEngine {
         )}`;
       }
       return `'${nestedItem.name}', ${escapeColumnName(nestedItem.selector)}`;
-    }).filter(Boolean).join(",")}
+    }).filter(Boolean).join(", ")}
 						)) 
 						FROM
 							"${item.subquery.table}"
@@ -1896,10 +2051,12 @@ var PsqlEngine = class extends SqlEngine {
       req.requesterDetails.role,
       sqlParams
     );
-    let deleteStatement = `DELETE
-                           FROM "${routeData.table}" ${joinStatement}`;
-    deleteStatement += this.generateWhereClause(req, routeData.where, routeData, sqlParams);
-    deleteStatement += ";";
+    const whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    if (whereClause.replace(/\s/g, "") === "") {
+      throw new RsError("DELETE_FORBIDDEN", "Deletes need a where clause");
+    }
+    const deleteStatement = `
+DELETE FROM "${routeData.table}" ${joinStatement} ${whereClause}`;
     await this.psqlConnectionPool.runQuery(deleteStatement, sqlParams, req.requesterDetails);
     return true;
   }
@@ -1962,17 +2119,17 @@ var PsqlEngine = class extends SqlEngine {
         );
       let operator = item.operator;
       if (operator === "LIKE") {
-        sqlParams[sqlParams.length - 1] = `%${sqlParams[sqlParams.length - 1]}%`;
+        item.value = `%${item.value}%`;
       } else if (operator === "STARTS WITH") {
         operator = "LIKE";
-        sqlParams[sqlParams.length - 1] = `${sqlParams[sqlParams.length - 1]}%`;
+        item.value = `${item.value}%`;
       } else if (operator === "ENDS WITH") {
         operator = "LIKE";
-        sqlParams[sqlParams.length - 1] = `%${sqlParams[sqlParams.length - 1]}`;
+        item.value = `%${item.value}`;
       }
       const replacedValue = this.replaceParamKeywords(item.value, routeData, req, sqlParams);
       const escapedValue = SQL`${replacedValue}`;
-      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator} ${["IN", "NOT IN"].includes(operator) ? `(${escapedValue})` : escapedValue}
+      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator.replace("LIKE", "ILIKE")} ${["IN", "NOT IN"].includes(operator) ? `(${escapedValue})` : escapedValue}
 `;
     });
     const data = req.data;
@@ -2006,7 +2163,67 @@ var PsqlEngine = class extends SqlEngine {
     }
     return whereClause;
   }
+  createUpdateTrigger(tableName) {
+    return ` 
+CREATE OR REPLACE FUNCTION notify_${tableName}_update()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('update', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+    AFTER UPDATE ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+		`;
+  }
+  createDeleteTrigger(tableName) {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('delete', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_delete"
+    AFTER DELETE ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_delete();
+		`;
+  }
+  createInsertTriggers(tableName) {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('insert', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER "${tableName}_insert"
+    AFTER INSERT ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+		`;
+  }
 };
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "handleTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createUpdateTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createDeleteTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createInsertTriggers", 1);
 function schemaToPsqlType(column, tableName) {
   if (column.hasAutoIncrement) return "BIGSERIAL";
   if (column.type === "ENUM") return `"${tableName}_${column.name}_enum"`;
@@ -2015,35 +2232,6 @@ function schemaToPsqlType(column, tableName) {
   return column.type;
 }
 
-// src/restura/sql/PsqlTransaction.ts
-var import_pg3 = __toESM(require("pg"));
-var { Client: Client2 } = import_pg3.default;
-var PsqlTransaction = class extends PsqlConnection {
-  constructor(clientConfig) {
-    super();
-    this.clientConfig = clientConfig;
-    this.client = new Client2(clientConfig);
-    this.beginTransactionPromise = this.beginTransaction();
-  }
-  async beginTransaction() {
-    return this.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.client.connect();
-    await this.beginTransactionPromise;
-    return this.client.query(query, values);
-  }
-};
-
 // src/restura/compareSchema.ts
 var import_lodash = __toESM(require("lodash.clonedeep"));
 var CompareSchema = class {
@@ -2135,7 +2323,7 @@ var compareSchema = new CompareSchema();
 var compareSchema_default = compareSchema;
 
 // src/restura/restura.ts
-var { types } = import_pg4.default;
+var { types } = import_pg3.default;
 var ResturaEngine = class {
   constructor() {
     this.publicEndpoints = {
@@ -2510,6 +2698,35 @@ var setupPgReturnTypes = () => {
 };
 setupPgReturnTypes();
 var restura = new ResturaEngine();
+
+// src/restura/sql/PsqlTransaction.ts
+var import_pg4 = __toESM(require("pg"));
+var { Client: Client2 } = import_pg4.default;
+var PsqlTransaction = class extends PsqlConnection {
+  constructor(clientConfig) {
+    super();
+    this.clientConfig = clientConfig;
+    this.client = new Client2(clientConfig);
+    this.beginTransactionPromise = this.beginTransaction();
+  }
+  async beginTransaction() {
+    return this.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.client.connect();
+    await this.beginTransactionPromise;
+    return this.client.query(query, values);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HtmlStatusCodes,
@@ -2519,6 +2736,7 @@ var restura = new ResturaEngine();
   RsError,
   SQL,
   escapeColumnName,
+  eventManager,
   insertObjectQuery,
   isValueNumber,
   logger,