@restura/core 0.1.0-alpha.9 → 0.1.1

package/dist/index.js

@@ -68,10 +68,15 @@ var __decorateClass = (decorators, target, key, kind) => {
 var src_exports = {};
 __export(src_exports, {
   HtmlStatusCodes: () => HtmlStatusCodes,
+  PsqlConnection: () => PsqlConnection,
+  PsqlEngine: () => PsqlEngine,
   PsqlPool: () => PsqlPool,
+  PsqlTransaction: () => PsqlTransaction,
   RsError: () => RsError,
   SQL: () => SQL,
   escapeColumnName: () => escapeColumnName,
+  eventManager: () => eventManager_default,
+  filterPsqlParser: () => filterPsqlParser_default,
   insertObjectQuery: () => insertObjectQuery,
   isValueNumber: () => isValueNumber2,
   logger: () => logger,
@@ -86,18 +91,11 @@ var import_internal = require("@restura/internal");
 var import_winston = __toESM(require("winston"));
 var import_logform = require("logform");
 
-// src/config.schema.ts
+// src/logger/loggerConfigSchema.ts
 var import_zod = require("zod");
 var loggerConfigSchema = import_zod.z.object({
   level: import_zod.z.enum(["info", "warn", "error", "debug", "silly"]).default("info")
 });
-var resturaConfigSchema = import_zod.z.object({
-  authToken: import_zod.z.string().min(1, "Missing Restura Auth Token"),
-  sendErrorStackTrace: import_zod.z.boolean().default(false),
-  schemaFilePath: import_zod.z.string().default(process.cwd() + "/restura.schema.json"),
-  customApiFolderPath: import_zod.z.string().default(process.cwd() + "/dist/api"),
-  generatedTypesPath: import_zod.z.string().default(process.cwd() + "/src/@types")
-});
 
 // src/logger/logger.ts
 var loggerConfig = import_internal.config.validate("logger", loggerConfigSchema);
@@ -134,7 +132,198 @@ var logger = import_winston.default.createLogger({
   ]
 });
 
-// src/restura/errors.ts
+// 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,
+          insertedId: triggerResult.insertedId || 0,
+          insertObject: triggerResult.record,
+          queryMetadata: data.queryMetadata
+        };
+        callback(insertData, data.queryMetadata);
+      },
+      { 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,
+          deletedId: triggerResult.deletedId || 0,
+          deletedRow: triggerResult.previousRecord,
+          queryMetadata: data.queryMetadata
+        };
+        callback(deleteData, data.queryMetadata);
+      },
+      { 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,
+          changedId: triggerResult.changedId || 0,
+          newData: triggerResult.record,
+          oldData: triggerResult.previousRecord,
+          queryMetadata: data.queryMetadata
+        };
+        callback(columnChangeData, data.queryMetadata);
+      },
+      { 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 !== triggerResult.table) return false;
+          if (filterColumnChange.columns.length === 1) {
+            const firstColumn = filterColumnChange.columns[0];
+            if (firstColumn === "*") return true;
+          }
+          if (!filterColumnChange.columns.some((item) => {
+            const updatedColumns = Object.keys(
+              changedValues(triggerResult.record, triggerResult.previousRecord)
+            );
+            return updatedColumns.includes(item);
+          }))
+            return false;
+          break;
+      }
+    }
+    return true;
+  }
+};
+var eventManager = new EventManager();
+var eventManager_default = eventManager;
+function changedValues(record, previousRecord) {
+  const changed = {};
+  for (const i in previousRecord) {
+    if (previousRecord[i] !== record[i]) {
+      if (typeof previousRecord[i] === "object" && typeof record[i] === "object") {
+        const nestedChanged = changedValues(record[i], previousRecord[i]);
+        if (Object.keys(nestedChanged).length > 0) {
+          changed[i] = record[i];
+        }
+      } else {
+        changed[i] = record[i];
+      }
+    }
+  }
+  return changed;
+}
+
+// src/restura/restura.ts
+var import_core_utils7 = require("@redskytech/core-utils");
+var import_internal4 = require("@restura/internal");
+
+// ../../node_modules/.pnpm/autobind-decorator@2.4.0/node_modules/autobind-decorator/lib/esm/index.js
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+function boundMethod(target, key, descriptor) {
+  var fn = descriptor.value;
+  if (typeof fn !== "function") {
+    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
+  }
+  var definingProperty = false;
+  return {
+    configurable: true,
+    get: function get() {
+      if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== "function") {
+        return fn;
+      }
+      var boundFn = fn.bind(this);
+      definingProperty = true;
+      Object.defineProperty(this, key, {
+        configurable: true,
+        get: function get2() {
+          return boundFn;
+        },
+        set: function set(value) {
+          fn = value;
+          delete this[key];
+        }
+      });
+      definingProperty = false;
+      return boundFn;
+    },
+    set: function set(value) {
+      fn = value;
+    }
+  };
+}
+
+// src/restura/restura.ts
+var import_body_parser = __toESM(require("body-parser"));
+var import_compression = __toESM(require("compression"));
+var import_cookie_parser = __toESM(require("cookie-parser"));
+var express = __toESM(require("express"));
+var import_fs4 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var prettier3 = __toESM(require("prettier"));
+
+// src/restura/RsError.ts
 var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
   HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
   HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
@@ -158,7 +347,6 @@ var RsError = class _RsError {
   static htmlStatus(code) {
     return htmlStatusMap[code];
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isRsError(error) {
     return error instanceof _RsError;
   }
@@ -200,73 +388,171 @@ var htmlStatusMap = {
   SCHEMA_ERROR: 500 /* SERVER_ERROR */
 };
 
-// src/restura/restura.ts
-var import_core_utils6 = require("@redskytech/core-utils");
-var import_internal2 = require("@restura/internal");
-
-// ../../node_modules/.pnpm/autobind-decorator@2.4.0/node_modules/autobind-decorator/lib/esm/index.js
-function _typeof(obj) {
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function _typeof2(obj2) {
-      return typeof obj2;
-    };
-  } else {
-    _typeof = function _typeof2(obj2) {
-      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+// src/restura/compareSchema.ts
+var import_lodash = __toESM(require("lodash.clonedeep"));
+var CompareSchema = class {
+  async diffSchema(newSchema, latestSchema, psqlEngine) {
+    const endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
+    const globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
+    const roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
+    let commands = "";
+    if (JSON.stringify(newSchema.database) !== JSON.stringify(latestSchema.database))
+      commands = await psqlEngine.diffDatabaseToSchema(newSchema);
+    const hasCustomTypesChanged = JSON.stringify(newSchema.customTypes) !== JSON.stringify(latestSchema.customTypes);
+    const schemaPreview = {
+      endPoints,
+      globalParams,
+      roles,
+      commands,
+      customTypes: hasCustomTypesChanged
     };
-  }
-  return _typeof(obj);
-}
-function boundMethod(target, key, descriptor) {
-  var fn = descriptor.value;
-  if (typeof fn !== "function") {
-    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
-  }
-  var definingProperty = false;
-  return {
-    configurable: true,
-    get: function get() {
-      if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== "function") {
-        return fn;
+    return schemaPreview;
+  }
+  diffStringArray(newArray, originalArray) {
+    const stringsDiff = [];
+    const originalClone = new Set(originalArray);
+    newArray.forEach((item) => {
+      const originalIndex = originalClone.has(item);
+      if (!originalIndex) {
+        stringsDiff.push({
+          name: item,
+          changeType: "NEW"
+        });
+      } else {
+        originalClone.delete(item);
       }
-      var boundFn = fn.bind(this);
-      definingProperty = true;
-      Object.defineProperty(this, key, {
-        configurable: true,
-        get: function get2() {
-          return boundFn;
-        },
-        set: function set(value) {
-          fn = value;
-          delete this[key];
+    });
+    originalClone.forEach((item) => {
+      stringsDiff.push({
+        name: item,
+        changeType: "DELETED"
+      });
+    });
+    return stringsDiff;
+  }
+  diffEndPoints(newEndPoints, originalEndpoints) {
+    const originalClone = (0, import_lodash.default)(originalEndpoints);
+    const diffObj = [];
+    newEndPoints.forEach((endPoint) => {
+      const { path: path5, method } = endPoint;
+      const endPointIndex = originalClone.findIndex((original) => {
+        return original.path === endPoint.path && original.method === endPoint.method;
+      });
+      if (endPointIndex === -1) {
+        diffObj.push({
+          name: `${method} ${path5}`,
+          changeType: "NEW"
+        });
+      } else {
+        const original = originalClone.findIndex((original2) => {
+          return this.compareEndPoints(endPoint, original2);
+        });
+        if (original === -1) {
+          diffObj.push({
+            name: `${method} ${path5}`,
+            changeType: "MODIFIED"
+          });
         }
+        originalClone.splice(endPointIndex, 1);
+      }
+    });
+    originalClone.forEach((original) => {
+      const { path: path5, method } = original;
+      diffObj.push({
+        name: `${method} ${path5}`,
+        changeType: "DELETED"
       });
-      definingProperty = false;
-      return boundFn;
-    },
-    set: function set(value) {
-      fn = value;
+    });
+    return diffObj;
+  }
+  compareEndPoints(endPoint1, endPoint2) {
+    return JSON.stringify(endPoint1) === JSON.stringify(endPoint2);
+  }
+};
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffSchema", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffStringArray", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffEndPoints", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "compareEndPoints", 1);
+var compareSchema = new CompareSchema();
+var compareSchema_default = compareSchema;
+
+// src/restura/customApiFactory.ts
+var import_bluebird2 = __toESM(require("bluebird"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_internal2 = require("@restura/internal");
+var CustomApiFactory = class {
+  constructor() {
+    this.customApis = {};
+  }
+  async loadApiFiles(baseFolderPath) {
+    const apiVersions = ["v1"];
+    for (const apiVersion of apiVersions) {
+      const apiVersionFolderPath = import_path.default.join(baseFolderPath, apiVersion);
+      const directoryExists = await import_internal2.FileUtils.existDir(apiVersionFolderPath);
+      if (!directoryExists) continue;
+      await this.addDirectory(apiVersionFolderPath, apiVersion);
     }
-  };
-}
+  }
+  getCustomApi(customApiName) {
+    return this.customApis[customApiName];
+  }
+  async addDirectory(directoryPath, apiVersion) {
+    var _a2;
+    const entries = await import_fs.default.promises.readdir(directoryPath, {
+      withFileTypes: true
+    });
+    const isTsx2 = (_a2 = process.argv[1]) == null ? void 0 : _a2.endsWith(".ts");
+    const isTsNode2 = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
+    const extension = isTsx2 || isTsNode2 ? "ts" : "js";
+    const shouldEndWith = `.api.${apiVersion}.${extension}`;
+    await import_bluebird2.default.map(entries, async (entry) => {
+      if (entry.isFile()) {
+        if (entry.name.endsWith(shouldEndWith) === false) return;
+        try {
+          const importPath = `${import_path.default.join(directoryPath, entry.name)}`;
+          const ApiImport = await import(importPath);
+          const customApiClass = new ApiImport.default();
+          logger.info(`Registering custom API: ${ApiImport.default.name}`);
+          this.bindMethodsToInstance(customApiClass);
+          this.customApis[ApiImport.default.name] = customApiClass;
+        } catch (e) {
+          logger.error(e);
+        }
+      }
+    });
+  }
+  bindMethodsToInstance(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    Object.getOwnPropertyNames(proto).forEach((key) => {
+      const property = instance[key];
+      if (typeof property === "function" && key !== "constructor") {
+        instance[key] = property.bind(instance);
+      }
+    });
+  }
+};
+var customApiFactory = new CustomApiFactory();
+var customApiFactory_default = customApiFactory;
 
-// src/restura/restura.ts
-var import_body_parser = __toESM(require("body-parser"));
-var import_compression = __toESM(require("compression"));
-var import_cookie_parser = __toESM(require("cookie-parser"));
-var import_crypto = require("crypto");
-var express = __toESM(require("express"));
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_pg2 = __toESM(require("pg"));
-var prettier3 = __toESM(require("prettier"));
+// src/restura/generators/apiGenerator.ts
+var import_core_utils = require("@redskytech/core-utils");
+var import_prettier = __toESM(require("prettier"));
 
 // src/restura/sql/SqlUtils.ts
 var SqlUtils = class _SqlUtils {
   static convertDatabaseTypeToTypescript(type, value) {
     type = type.toLocaleLowerCase();
     if (type.startsWith("tinyint") || type.startsWith("boolean")) return "boolean";
-    if (type.indexOf("int") > -1 || type.startsWith("decimal") || type.startsWith("double") || type.startsWith("float"))
+    if (type.indexOf("int") > -1 || type.startsWith("decimal") || type.startsWith("double") || type.startsWith("float") || type.indexOf("serial") > -1 || type.startsWith("decimal") || type.startsWith("real") || type.startsWith("double precision") || type.startsWith("numeric"))
       return "number";
     if (type === "json") {
       if (!value) return "object";
@@ -287,7 +573,7 @@ var SqlUtils = class _SqlUtils {
   }
 };
 
-// src/restura/ResponseValidator.ts
+// src/restura/validators/ResponseValidator.ts
 var ResponseValidator = class _ResponseValidator {
   constructor(schema) {
     this.database = schema.database;
@@ -352,9 +638,9 @@ var ResponseValidator = class _ResponseValidator {
     return { validator: "any" };
   }
   getTypeFromTable(selector, name) {
-    const path4 = selector.split(".");
-    if (path4.length === 0 || path4.length > 2 || path4[0] === "") return { validator: "any", isOptional: false };
-    const tableName = path4.length == 2 ? path4[0] : name, columnName = path4.length == 2 ? path4[1] : path4[0];
+    const path5 = selector.split(".");
+    if (path5.length === 0 || path5.length > 2 || path5[0] === "") return { validator: "any", isOptional: false };
+    const tableName = path5.length == 2 ? path5[0] : name, columnName = path5.length == 2 ? path5[1] : path5[0];
     const table = this.database.find((t) => t.name == tableName);
     const column = table == null ? void 0 : table.columns.find((c) => c.name == columnName);
     if (!table || !column) return { validator: "any", isOptional: false };
@@ -436,9 +722,7 @@ var ResponseValidator = class _ResponseValidator {
   }
 };
 
-// src/restura/apiGenerator.ts
-var import_core_utils = require("@redskytech/core-utils");
-var import_prettier = __toESM(require("prettier"));
+// src/restura/generators/apiGenerator.ts
 var ApiTree = class _ApiTree {
   constructor(namespace, database) {
     this.database = database;
@@ -536,7 +820,7 @@ var ApiTree = class _ApiTree {
             break;
         }
       }
-      return `'${p.name}'${p.required ? "" : "?"}:${requestType}`;
+      return `'${p.name}'${p.required ? "" : "?"}:${requestType}${p.isNullable ? " | null" : ""}`;
     }).join(";\n")}${import_core_utils.ObjectUtils.isArrayWithData(route.request) ? ";" : ""}
 		 `;
     modelString += `}`;
@@ -550,30 +834,37 @@ var ApiTree = class _ApiTree {
         return `export type Res = CustomTypes.${route.responseType}[]`;
       else return `export type Res = CustomTypes.${route.responseType}`;
     }
-    return `export interface Res ${this.getFields(route.response)}`;
+    return `export interface Res ${this.getFields(route.response, route.table, route.joins)}`;
   }
-  getFields(fields) {
-    const nameFields = fields.map((f) => this.getNameAndType(f));
+  getFields(fields, routeBaseTable, joins) {
+    const nameFields = fields.map((f) => this.getNameAndType(f, routeBaseTable, joins));
     const nested = `{
 			${nameFields.join(";\n	")}${import_core_utils.ObjectUtils.isArrayWithData(nameFields) ? ";" : ""}
 		}`;
     return nested;
   }
-  getNameAndType(p) {
-    let responseType = "any", optional = false, array = false;
+  getNameAndType(p, routeBaseTable, joins) {
+    let responseType = "any", isNullable = false, array = false;
     if (p.selector) {
-      ({ responseType, optional } = this.getTypeFromTable(p.selector, p.name));
+      ({ responseType, isNullable } = this.getTypeFromTable(p.selector, p.name));
+      const selectorKey = p.selector.split(".")[0];
+      if (selectorKey !== routeBaseTable) {
+        const join = joins.find((j) => j.alias === selectorKey);
+        if (join && join.type !== "INNER") {
+          isNullable = true;
+        }
+      }
     } else if (p.subquery) {
-      responseType = this.getFields(p.subquery.properties);
+      responseType = this.getFields(p.subquery.properties, p.subquery.table, p.subquery.joins);
       array = true;
     }
-    return `${p.name}${optional ? "?" : ""}:${responseType}${array ? "[]" : ""}`;
+    return `${p.name}:${responseType}${array ? "[]" : ""}${isNullable ? " | null" : ""}`;
   }
   getTypeFromTable(selector, name) {
-    const path4 = selector.split(".");
-    if (path4.length === 0 || path4.length > 2 || path4[0] === "") return { responseType: "any", optional: false };
-    let tableName = path4.length == 2 ? path4[0] : name;
-    const columnName = path4.length == 2 ? path4[1] : path4[0];
+    const path5 = selector.split(".");
+    if (path5.length === 0 || path5.length > 2 || path5[0] === "") return { responseType: "any", isNullable: false };
+    let tableName = path5.length == 2 ? path5[0] : name;
+    const columnName = path5.length == 2 ? path5[1] : path5[0];
     let table = this.database.find((t) => t.name == tableName);
     if (!table && tableName.includes("_")) {
       const tableAliasSplit = tableName.split("_");
@@ -581,18 +872,19 @@ var ApiTree = class _ApiTree {
       table = this.database.find((t) => t.name == tableName);
     }
     const column = table == null ? void 0 : table.columns.find((c) => c.name == columnName);
-    if (!table || !column) return { responseType: "any", optional: false };
+    if (!table || !column) return { responseType: "any", isNullable: false };
     return {
       responseType: SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value),
-      optional: column.roles.length > 0 || column.isNullable
+      isNullable: column.roles.length > 0 || column.isNullable
     };
   }
 };
-function pathToNamespaces(path4) {
-  return path4.split("/").map((e) => import_core_utils.StringUtils.toPascalCasing(e)).filter((e) => e);
+function pathToNamespaces(path5) {
+  return path5.split("/").map((e) => import_core_utils.StringUtils.toPascalCasing(e)).filter((e) => e);
 }
-function apiGenerator(schema, schemaHash) {
-  let apiString = `/** Auto generated file from Schema Hash (${schemaHash}). DO NOT MODIFY **/`;
+function apiGenerator(schema) {
+  let apiString = `/** Auto generated file. DO NOT MODIFY **/
+`;
   const rootNamespace = ApiTree.createRootNode(schema.database);
   for (const endpoint of schema.endpoints) {
     const endpointNamespaces = pathToNamespaces(endpoint.baseUrl);
@@ -607,7 +899,7 @@ function apiGenerator(schema, schemaHash) {
     apiString += `
 
 		declare namespace CustomTypes {
-			${schema.customTypes}
+			${schema.customTypes.join("\n")}
 		}`;
   }
   return import_prettier.default.format(apiString, __spreadValues({
@@ -622,79 +914,32 @@ function apiGenerator(schema, schemaHash) {
   }));
 }
 
-// src/restura/customApiFactory.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var CustomApiFactory = class {
-  constructor() {
-    this.customApis = {};
-  }
-  async loadApiFiles(baseFolderPath) {
-    const apiVersions = ["v1"];
-    for (const apiVersion of apiVersions) {
-      const apiVersionFolderPath = import_path.default.join(baseFolderPath, apiVersion);
-      if (!import_fs.default.existsSync(apiVersionFolderPath)) continue;
-      await this.addDirectory(apiVersionFolderPath, apiVersion);
-    }
-  }
-  getCustomApi(customApiName) {
-    return this.customApis[customApiName];
-  }
-  async addDirectory(directoryPath, apiVersion) {
-    const entries = import_fs.default.readdirSync(directoryPath, {
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        if (entry.name.endsWith(`.api.${apiVersion}.js`) === false) continue;
-        try {
-          const importPath = `${import_path.default.join(directoryPath, entry.name)}`;
-          const ApiImport = await import(importPath);
-          const customApiClass = new ApiImport.default();
-          logger.info(`Registering custom API: ${ApiImport.default.name}`);
-          this.bindMethodsToInstance(customApiClass);
-          this.customApis[ApiImport.default.name] = customApiClass;
-        } catch (e) {
-          console.error(e);
-        }
-      }
-    }
-  }
-  bindMethodsToInstance(instance) {
-    const proto = Object.getPrototypeOf(instance);
-    Object.getOwnPropertyNames(proto).forEach((key) => {
-      const property = instance[key];
-      if (typeof property === "function" && key !== "constructor") {
-        instance[key] = property.bind(instance);
-      }
-    });
-  }
-};
-var customApiFactory = new CustomApiFactory();
-var customApiFactory_default = customApiFactory;
-
-// src/restura/customTypeValidationGenerator.ts
+// src/restura/generators/customTypeValidationGenerator.ts
 var import_fs2 = __toESM(require("fs"));
-var TJS = __toESM(require("typescript-json-schema"));
 var import_path2 = __toESM(require("path"));
 var import_tmp = __toESM(require("tmp"));
-var process2 = __toESM(require("process"));
+var TJS = __toESM(require("typescript-json-schema"));
 function customTypeValidationGenerator(currentSchema) {
   const schemaObject = {};
-  const customInterfaceNames = currentSchema.customTypes.match(new RegExp("(?<=interface\\s)(\\w+)|(?<=type\\s)(\\w+)", "g"));
+  const customInterfaceNames = currentSchema.customTypes.map((customType) => {
+    const matches = customType.match(new RegExp("(?<=interface\\s)(\\w+)|(?<=type\\s)(\\w+)", "g"));
+    if (matches && matches.length > 0) return matches[0];
+    return "";
+  }).filter(Boolean);
   if (!customInterfaceNames) return {};
   const temporaryFile = import_tmp.default.fileSync({ mode: 420, prefix: "prefix-", postfix: ".ts" });
-  import_fs2.default.writeFileSync(temporaryFile.name, currentSchema.customTypes);
+  import_fs2.default.writeFileSync(temporaryFile.name, currentSchema.customTypes.join("\n"));
   const compilerOptions = {
     strictNullChecks: true,
     skipLibCheck: true
+    // Needed if we are processing ES modules
   };
   const program = TJS.getProgramFromFiles(
     [
       (0, import_path2.resolve)(temporaryFile.name),
-      // find a way to remove
-      import_path2.default.join(process2.cwd(), "src/@types/models.d.ts"),
-      import_path2.default.join(process2.cwd(), "src/@types/api.d.ts")
+      import_path2.default.join(restura.resturaConfig.generatedTypesPath, "restura.d.ts"),
+      import_path2.default.join(restura.resturaConfig.generatedTypesPath, "models.d.ts"),
+      import_path2.default.join(restura.resturaConfig.generatedTypesPath, "api.d.ts")
     ],
     compilerOptions
   );
@@ -708,6 +953,61 @@ function customTypeValidationGenerator(currentSchema) {
   return schemaObject;
 }
 
+// src/restura/generators/modelGenerator.ts
+var import_core_utils2 = require("@redskytech/core-utils");
+var import_prettier2 = __toESM(require("prettier"));
+function modelGenerator(schema) {
+  let modelString = `/** Auto generated file. DO NOT MODIFY **/
+
+`;
+  modelString += `declare namespace Model {
+`;
+  for (const table of schema.database) {
+    modelString += convertTable(table);
+  }
+  modelString += `}`;
+  return import_prettier2.default.format(modelString, __spreadValues({
+    parser: "typescript"
+  }, {
+    trailingComma: "none",
+    tabWidth: 4,
+    useTabs: true,
+    endOfLine: "lf",
+    printWidth: 120,
+    singleQuote: true
+  }));
+}
+function convertTable(table) {
+  let modelString = `	export interface ${import_core_utils2.StringUtils.capitalizeFirst(table.name)} {
+`;
+  for (const column of table.columns) {
+    modelString += `		${column.name}${column.isNullable ? "?" : ""}: ${SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value)};
+`;
+  }
+  modelString += `	}
+`;
+  return modelString;
+}
+
+// src/restura/generators/resturaGlobalTypesGenerator.ts
+function resturaGlobalTypesGenerator() {
+  return `/** Auto generated file. DO NOT MODIFY **/
+/** This file contains types that may be used in the CustomTypes of Restura **/
+/** For example export interface MyPagedQuery extends Restura.PageQuery { } **/
+
+declare namespace Restura {
+	export type StandardOrderTypes = 'ASC' | 'DESC' | 'RAND' | 'NONE';
+	export interface PageQuery {
+		page?: number;
+		perPage?: number;
+		sortBy?: string;
+		sortOrder?: StandardOrderTypes;
+		filter?: string;
+	}
+}
+`;
+}
+
 // src/restura/middleware/addApiResponseFunctions.ts
 function addApiResponseFunctions(req, res, next) {
   res.sendData = function(data, statusCode = 200) {
@@ -740,16 +1040,41 @@ function addApiResponseFunctions(req, res, next) {
 function authenticateUser(applicationAuthenticateHandler) {
   return (req, res, next) => {
     applicationAuthenticateHandler(req, res, (userDetails) => {
-      req.requesterDetails = __spreadValues(__spreadValues({}, req.requesterDetails), userDetails);
+      req.requesterDetails = __spreadValues({ host: req.hostname, ipAddress: req.ip || "" }, userDetails);
       next();
     });
   };
 }
 
-// src/restura/restura.schema.ts
+// src/restura/middleware/getMulterUpload.ts
+var import_multer = __toESM(require("multer"));
+var os = __toESM(require("os"));
+var import_path3 = require("path");
+var OneHundredMB = 100 * 1024 * 1024;
+var commonUpload = null;
+var getMulterUpload = (directory) => {
+  if (commonUpload) return commonUpload;
+  const storage = import_multer.default.diskStorage({
+    destination: directory || os.tmpdir(),
+    filename: function(request, file, cb) {
+      const extension = (0, import_path3.extname)(file.originalname);
+      const uniqueName = Date.now() + "-" + Math.round(Math.random() * 1e3);
+      cb(null, `${uniqueName}${extension}`);
+    }
+  });
+  commonUpload = (0, import_multer.default)({
+    storage,
+    limits: {
+      fileSize: OneHundredMB
+    }
+  });
+  return commonUpload;
+};
+
+// src/restura/schemas/resturaSchema.ts
 var import_zod3 = require("zod");
 
-// src/restura/types/validation.types.ts
+// src/restura/schemas/validatorDataSchema.ts
 var import_zod2 = require("zod");
 var validatorDataSchemeValue = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.string()), import_zod2.z.number(), import_zod2.z.array(import_zod2.z.number())]);
 var validatorDataSchema = import_zod2.z.object({
@@ -757,7 +1082,7 @@ var validatorDataSchema = import_zod2.z.object({
   value: validatorDataSchemeValue
 }).strict();
 
-// src/restura/restura.schema.ts
+// src/restura/schemas/resturaSchema.ts
 var orderBySchema = import_zod3.z.object({
   columnName: import_zod3.z.string(),
   order: import_zod3.z.enum(["ASC", "DESC"]),
@@ -770,7 +1095,7 @@ var groupBySchema = import_zod3.z.object({
 var whereDataSchema = import_zod3.z.object({
   tableName: import_zod3.z.string().optional(),
   columnName: import_zod3.z.string().optional(),
-  operator: import_zod3.z.enum(["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH"]).optional(),
+  operator: import_zod3.z.enum(["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH", "IS", "IS NOT"]).optional(),
   value: import_zod3.z.string().or(import_zod3.z.number()).optional(),
   custom: import_zod3.z.string().optional(),
   conjunction: import_zod3.z.enum(["AND", "OR"]).optional()
@@ -790,6 +1115,7 @@ var joinDataSchema = import_zod3.z.object({
 var requestDataSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
   required: import_zod3.z.boolean(),
+  isNullable: import_zod3.z.boolean().optional(),
   validator: import_zod3.z.array(validatorDataSchema)
 }).strict();
 var responseDataSchema = import_zod3.z.object({
@@ -875,6 +1201,12 @@ var postgresColumnDateTypesSchema = import_zod3.z.enum([
   "INTERVAL"
   // time span
 ]);
+var postgresColumnJsonTypesSchema = import_zod3.z.enum([
+  "JSON",
+  // stores JSON data as raw text
+  "JSONB"
+  // stores JSON data in a binary format, optimized for query performance
+]);
 var mariaDbColumnNumericTypesSchema = import_zod3.z.enum([
   "BOOLEAN",
   // 1-byte A synonym for "TINYINT(1)". Supported from version 1.2.0 onwards.
@@ -937,6 +1269,7 @@ var columnDataSchema = import_zod3.z.object({
     postgresColumnNumericTypesSchema,
     postgresColumnStringTypesSchema,
     postgresColumnDateTypesSchema,
+    postgresColumnJsonTypesSchema,
     mariaDbColumnNumericTypesSchema,
     mariaDbColumnStringTypesSchema,
     mariaDbColumnDateTypesSchema
@@ -988,7 +1321,8 @@ var tableDataSchema = import_zod3.z.object({
   indexes: import_zod3.z.array(indexDataSchema),
   foreignKeys: import_zod3.z.array(foreignKeyDataSchema),
   checkConstraints: import_zod3.z.array(checkConstraintDataSchema),
-  roles: import_zod3.z.array(import_zod3.z.string())
+  roles: import_zod3.z.array(import_zod3.z.string()),
+  notify: import_zod3.z.union([import_zod3.z.literal("ALL"), import_zod3.z.array(import_zod3.z.string())]).optional()
 }).strict();
 var endpointDataSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
@@ -996,16 +1330,16 @@ var endpointDataSchema = import_zod3.z.object({
   baseUrl: import_zod3.z.string(),
   routes: import_zod3.z.array(import_zod3.z.union([standardRouteSchema, customRouteSchema]))
 }).strict();
-var resturaZodSchema = import_zod3.z.object({
+var resturaSchema = import_zod3.z.object({
   database: import_zod3.z.array(tableDataSchema),
   endpoints: import_zod3.z.array(endpointDataSchema),
   globalParams: import_zod3.z.array(import_zod3.z.string()),
   roles: import_zod3.z.array(import_zod3.z.string()),
-  customTypes: import_zod3.z.string()
+  customTypes: import_zod3.z.array(import_zod3.z.string())
 }).strict();
 async function isSchemaValid(schemaToCheck) {
   try {
-    resturaZodSchema.parse(schemaToCheck);
+    resturaSchema.parse(schemaToCheck);
     return true;
   } catch (error) {
     logger.error(error);
@@ -1013,12 +1347,12 @@ async function isSchemaValid(schemaToCheck) {
   }
 }
 
-// src/restura/validateRequestParams.ts
-var import_core_utils2 = require("@redskytech/core-utils");
+// src/restura/validators/requestValidator.ts
+var import_core_utils3 = require("@redskytech/core-utils");
 var import_jsonschema = __toESM(require("jsonschema"));
 var import_zod4 = require("zod");
 
-// src/restura/utils/addQuotesToStrings.ts
+// src/restura/utils/utils.ts
 function addQuotesToStrings(variable) {
   if (typeof variable === "string") {
     return `'${variable}'`;
@@ -1029,9 +1363,20 @@ function addQuotesToStrings(variable) {
     return variable;
   }
 }
+function sortObjectKeysAlphabetically(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectKeysAlphabetically);
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj).sort().reduce((sorted, key) => {
+      sorted[key] = sortObjectKeysAlphabetically(obj[key]);
+      return sorted;
+    }, {});
+  }
+  return obj;
+}
 
-// src/restura/validateRequestParams.ts
-function validateRequestParams(req, routeData, validationSchema) {
+// src/restura/validators/requestValidator.ts
+function requestValidator(req, routeData, validationSchema) {
   const requestData = getRequestData(req);
   req.data = requestData;
   if (routeData.request === void 0) {
@@ -1065,6 +1410,7 @@ function validateRequestParams(req, routeData, validationSchema) {
   });
 }
 function validateRequestSingleParam(requestValue, requestParam) {
+  if (requestParam.isNullable && requestValue === null) return;
   requestParam.validator.forEach((validator) => {
     switch (validator.type) {
       case "TYPE_CHECK":
@@ -1152,7 +1498,7 @@ function performMaxCheck(requestValue, validator, requestParamName) {
     );
 }
 function performOneOfCheck(requestValue, validator, requestParamName) {
-  if (!import_core_utils2.ObjectUtils.isArrayWithData(validator.value))
+  if (!import_core_utils3.ObjectUtils.isArrayWithData(validator.value))
     throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value}) is not of type array`);
   if (typeof requestValue === "object")
     throw new RsError("BAD_REQUEST", `Request param (${requestParamName}) is not of type string or number`);
@@ -1181,13 +1527,19 @@ function getRequestData(req) {
           if (isNaN(Number(value))) continue;
           attrList.push(Number(value));
         }
-        if (import_core_utils2.ObjectUtils.isArrayWithData(attrList)) {
+        if (import_core_utils3.ObjectUtils.isArrayWithData(attrList)) {
           bodyData[attr] = attrList;
         }
       } else {
-        bodyData[attr] = import_core_utils2.ObjectUtils.safeParse(bodyData[attr]);
-        if (isNaN(Number(bodyData[attr]))) continue;
-        bodyData[attr] = Number(bodyData[attr]);
+        if (bodyData[attr] === "true") {
+          bodyData[attr] = true;
+        } else if (bodyData[attr] === "false") {
+          bodyData[attr] = false;
+        } else {
+          bodyData[attr] = import_core_utils3.ObjectUtils.safeParse(bodyData[attr]);
+          if (isNaN(Number(bodyData[attr]))) continue;
+          bodyData[attr] = Number(bodyData[attr]);
+        }
       }
     }
   }
@@ -1198,7 +1550,7 @@ function getRequestData(req) {
 async function schemaValidation(req, res, next) {
   req.data = getRequestData(req);
   try {
-    resturaZodSchema.parse(req.data);
+    resturaSchema.parse(req.data);
     next();
   } catch (error) {
     logger.error(error);
@@ -1206,43 +1558,33 @@ async function schemaValidation(req, res, next) {
   }
 }
 
-// src/restura/modelGenerator.ts
-var import_core_utils3 = require("@redskytech/core-utils");
-var import_prettier2 = __toESM(require("prettier"));
-function modelGenerator(schema, schemaHash) {
-  let modelString = `/** Auto generated file from Schema Hash (${schemaHash}). DO NOT MODIFY **/
-`;
-  modelString += `declare namespace Model {
-`;
-  for (const table of schema.database) {
-    modelString += convertTable(table);
-  }
-  modelString += `}`;
-  return import_prettier2.default.format(modelString, __spreadValues({
-    parser: "typescript"
-  }, {
-    trailingComma: "none",
-    tabWidth: 4,
-    useTabs: true,
-    endOfLine: "lf",
-    printWidth: 120,
-    singleQuote: true
-  }));
-}
-function convertTable(table) {
-  let modelString = `	export interface ${import_core_utils3.StringUtils.capitalizeFirst(table.name)} {
-`;
-  for (const column of table.columns) {
-    modelString += `		${column.name}${column.isNullable ? "?" : ""}: ${SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value)};
-`;
-  }
-  modelString += `	}
-`;
-  return modelString;
-}
+// src/restura/schemas/resturaConfigSchema.ts
+var import_zod5 = require("zod");
+var _a;
+var isTsx = (_a = process.argv[1]) == null ? void 0 : _a.endsWith(".ts");
+var isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
+var customApiFolderPath = isTsx || isTsNode ? "/src/api" : "/dist/api";
+var resturaConfigSchema = import_zod5.z.object({
+  authToken: import_zod5.z.string().min(1, "Missing Restura Auth Token"),
+  sendErrorStackTrace: import_zod5.z.boolean().default(false),
+  schemaFilePath: import_zod5.z.string().default(process.cwd() + "/restura.schema.json"),
+  customApiFolderPath: import_zod5.z.string().default(process.cwd() + customApiFolderPath),
+  generatedTypesPath: import_zod5.z.string().default(process.cwd() + "/src/@types"),
+  fileTempCachePath: import_zod5.z.string().optional()
+});
 
 // src/restura/sql/PsqlEngine.ts
 var import_core_utils5 = require("@redskytech/core-utils");
+var import_pg_diff_sync = __toESM(require("@wmfs/pg-diff-sync"));
+var import_pg_info = __toESM(require("@wmfs/pg-info"));
+var import_pg2 = __toESM(require("pg"));
+
+// src/restura/sql/PsqlPool.ts
+var import_pg = __toESM(require("pg"));
+
+// src/restura/sql/PsqlConnection.ts
+var import_crypto = __toESM(require("crypto"));
+var import_pg_format2 = __toESM(require("pg-format"));
 
 // src/restura/sql/PsqlUtils.ts
 var import_pg_format = __toESM(require("pg-format"));
@@ -1252,16 +1594,33 @@ function escapeColumnName(columnName) {
 }
 function questionMarksToOrderedParams(query) {
   let count = 1;
-  return query.replace(/'\?'|\?/g, () => `$${count++}`);
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  return query.replace(/('|"|\?)/g, (char) => {
+    if (char === "'") {
+      inSingleQuote = !inSingleQuote && !inDoubleQuote;
+      return char;
+    }
+    if (char === '"') {
+      inDoubleQuote = !inDoubleQuote && !inSingleQuote;
+      return char;
+    }
+    if (char === "?" && !inSingleQuote && !inDoubleQuote) {
+      return `$${count++}`;
+    }
+    return char;
+  });
 }
 function insertObjectQuery(table, obj) {
   const keys = Object.keys(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})
+  let query = `
+INSERT INTO "${table}" (${columns})
                  VALUES (${values})
                  RETURNING *`;
+  query = query.replace(/'(\?)'/, "?");
   return query;
 }
 function updateObjectQuery(table, obj, whereStatement) {
@@ -1269,25 +1628,113 @@ function updateObjectQuery(table, obj, whereStatement) {
   for (const i in obj) {
     setArray.push(`${escapeColumnName(i)} = ` + SQL`${obj[i]}`);
   }
-  return `UPDATE ${escapeColumnName(table)}
-                 SET ${setArray.join(", ")} ${whereStatement}
-                 RETURNING *`;
-}
-function isValueNumber2(value) {
-  return !isNaN(Number(value));
-}
-function SQL(strings, ...values) {
-  let query = strings[0];
-  values.forEach((value, index) => {
-    if (isValueNumber2(value)) {
-      query += value;
+  return `
+UPDATE ${escapeColumnName(table)}
+                 SET ${setArray.join(", ")} ${whereStatement}
+                 RETURNING *`;
+}
+function isValueNumber2(value) {
+  return !isNaN(Number(value));
+}
+function SQL(strings, ...values) {
+  let query = strings[0];
+  values.forEach((value, index) => {
+    if (typeof value === "boolean") {
+      query += value;
+    } else if (typeof value === "number") {
+      query += value;
+    } else if (Array.isArray(value)) {
+      query += import_pg_format.default.literal(JSON.stringify(value)) + "::jsonb";
+    } else {
+      query += import_pg_format.default.literal(value);
+    }
+    query += strings[index + 1];
+  });
+  return query;
+}
+
+// src/restura/sql/PsqlConnection.ts
+var PsqlConnection = class {
+  constructor(instanceId) {
+    this.instanceId = instanceId || import_crypto.default.randomUUID();
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  async queryOne(query, options, requesterDetails) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const meta = __spreadValues({ connectionInstanceId: this.instanceId }, requesterDetails);
+    this.logSqlStatement(formattedQuery, options, meta);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
+`;
+    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");
+      return response.rows[0];
+    } catch (error) {
+      if (RsError.isRsError(error)) throw error;
+      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  async runQuery(query, options, requesterDetails) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const meta = __spreadValues({ connectionInstanceId: this.instanceId }, requesterDetails);
+    this.logSqlStatement(formattedQuery, options, meta);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(meta)})
+`;
+    try {
+      const response = await this.query(queryMetadata + formattedQuery, options);
+      return response.rows;
+    } catch (error) {
+      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+  logSqlStatement(query, options, queryMetadata, prefix = "") {
+    if (logger.level !== "silly") return;
+    let sqlStatement = "";
+    if (options.length === 0) {
+      sqlStatement = query;
     } else {
-      query += import_pg_format.default.literal(value);
+      let stringIndex = 0;
+      sqlStatement = query.replace(/\$\d+/g, () => {
+        const value = options[stringIndex++];
+        if (typeof value === "number") return value.toString();
+        return import_pg_format2.default.literal(value);
+      });
     }
-    query += strings[index + 1];
-  });
-  return query;
-}
+    let initiator = "Anonymous";
+    if ("userId" in queryMetadata && queryMetadata.userId)
+      initiator = `User Id (${queryMetadata.userId.toString()})`;
+    if ("isSystemUser" in queryMetadata && queryMetadata.isSystemUser) initiator = "SYSTEM";
+    logger.silly(`${prefix}query by ${initiator}, Query ->
+ ${sqlStatement}`);
+  }
+};
+
+// src/restura/sql/PsqlPool.ts
+var { Pool } = import_pg.default;
+var PsqlPool = class extends PsqlConnection {
+  constructor(poolConfig) {
+    super();
+    this.poolConfig = poolConfig;
+    this.pool = new Pool(poolConfig);
+    this.queryOne("SELECT NOW();", [], { isSystemUser: true, role: "", host: "localhost", ipAddress: "" }).then(() => {
+      logger.info("Connected to PostgreSQL database");
+    }).catch((error) => {
+      logger.error("Error connecting to database", error);
+      process.exit(1);
+    });
+  }
+  async query(query, values) {
+    return this.pool.query(query, values);
+  }
+};
 
 // src/restura/sql/SqlEngine.ts
 var import_core_utils4 = require("@redskytech/core-utils");
@@ -1355,11 +1802,11 @@ var SqlEngine = class {
     return returnValue;
   }
   replaceLocalParamKeywords(value, routeData, req, sqlParams) {
-    var _a;
+    var _a2;
     if (!routeData.request) return value;
     const data = req.data;
     if (typeof value === "string") {
-      (_a = value.match(/\$[a-zA-Z][a-zA-Z0-9_]+/g)) == null ? void 0 : _a.forEach((param) => {
+      (_a2 = value.match(/\$[a-zA-Z][a-zA-Z0-9_]+/g)) == null ? void 0 : _a2.forEach((param) => {
         const requestParam = routeData.request.find((item) => {
           return item.name === param.replace("$", "");
         });
@@ -1372,9 +1819,9 @@ var SqlEngine = class {
     return value;
   }
   replaceGlobalParamKeywords(value, routeData, req, sqlParams) {
-    var _a;
+    var _a2;
     if (typeof value === "string") {
-      (_a = value.match(/#[a-zA-Z][a-zA-Z0-9_]+/g)) == null ? void 0 : _a.forEach((param) => {
+      (_a2 = value.match(/#[a-zA-Z][a-zA-Z0-9_]+/g)) == null ? void 0 : _a2.forEach((param) => {
         param = param.replace("#", "");
         const globalParamValue = req.requesterDetails[param];
         if (!globalParamValue)
@@ -1393,32 +1840,86 @@ var SqlEngine = class {
 // src/restura/sql/filterPsqlParser.ts
 var import_pegjs = __toESM(require("pegjs"));
 var filterSqlGrammar = `
+{
+// ported from pg-format but intentionally will add double quotes to every column
+ function quoteSqlIdentity(value) {
+    if (value === undefined || value === null) {
+        throw new Error('SQL identifier cannot be null or undefined');
+    } else if (value === false) {
+        return '"f"';
+    } else if (value === true) {
+        return '"t"';
+    } else if (value instanceof Date) {
+        // return '"' + formatDate(value.toISOString()) + '"';
+    } else if (value instanceof Buffer) {
+        throw new Error('SQL identifier cannot be a buffer');
+    } else if (Array.isArray(value) === true) {
+        var temp = [];
+        for (var i = 0; i < value.length; i++) {
+            if (Array.isArray(value[i]) === true) {
+                throw new Error('Nested array to grouped list conversion is not supported for SQL identifier');
+            } else {
+                // temp.push(quoteIdent(value[i]));
+            }
+        }
+        return temp.toString();
+    } else if (value === Object(value)) {
+        throw new Error('SQL identifier cannot be an object');
+    }
+
+    var ident = value.toString().slice(0); // create copy
+
+    // do not quote a valid, unquoted identifier
+    // if (/^[a-z_][a-z0-9_$]*$/.test(ident) === true && isReserved(ident) === false) {
+    //     return ident;
+    // }
+
+    var quoted = '"';
+
+    for (var i = 0; i < ident.length; i++) {
+        var c = ident[i];
+        if (c === '"') {
+            quoted += c + c;
+        } else {
+            quoted += c;
+        }
+    }
+
+    quoted += '"';
+
+    return quoted;
+};
+}
+
 start = expressionList
 
+_ = [ \\t\\r\\n]*  // Matches spaces, tabs, and line breaks
+
 expressionList =
-        leftExpression:expression operator:operator rightExpression:expressionList 
+    leftExpression:expression _ operator:operator _ rightExpression:expressionList 
     { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
     / expression
 
 expression = 
-    negate:negate?"(" "column:" column:column ","? value:value? ","? type:type? ")" 
-    {return \`\${negate? "!" : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
+    negate:negate? _ "(" _ "column" _ ":"  column:column _ ","? _ value:value? ","? _ type:type? _ ")"_
+    {return \`\${negate? " NOT " : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
     /
-    negate:negate?"("expression:expressionList")" { return \`\${negate? "!" : ""}(\${expression})\`; }
+    negate:negate?"("expression:expressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
 
 negate = "!"
     
 operator = "and"i / "or"i
 
 	   
-column = left:text "." right:text { return  \`\${format.ident(left)}.\${format.ident(right)}\`; } 
+column = left:text "." right:text { return  \`\${quoteSqlIdentity(left)}.\${quoteSqlIdentity(right)}\`; } 
     / 
-    text:text { return format.ident(text); } 
+    text:text { return quoteSqlIdentity(text); } 
     
 
-text = text:[a-z0-9-_:@]i+ { return text.join("");}
+text = text:[a-z0-9 \\t\\r\\n\\-_:@']i+ { return text.join(""); }
+
 
-type = "type:" type:typeString { return type; }
+type = "type" _ ":" _ type:typeString { return type; }
 typeString = 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)}%'\`; } } /
@@ -1428,8 +1929,9 @@ typeString = text:"startsWith" { return function(column, value) { return \`\${co
     text:"lessThanEqual" { return function(column, value) { return \`\${column} <= '\${format.literal(value).slice(1,-1)}'\`; } } /
     text:"lessThan" { return function(column, value) { return \`\${column} < '\${format.literal(value).slice(1,-1)}'\`; } } / 
     text:"isNull"   { return function(column, value) { return \`isNull(\${column})\`; } } 
-    
-value = "value:" value:text { return value; } 
+
+value = "value" _ ":" value:text { return value; }
+
 
 `;
 var filterPsqlParser = import_pegjs.default.generate(filterSqlGrammar, {
@@ -1439,18 +1941,224 @@ var filterPsqlParser = import_pegjs.default.generate(filterSqlGrammar, {
 var filterPsqlParser_default = filterPsqlParser;
 
 // src/restura/sql/PsqlEngine.ts
+var { Client, types } = import_pg2.default;
+var systemUser = {
+  role: "",
+  host: "",
+  ipAddress: "",
+  isSystemUser: true
+};
 var PsqlEngine = class extends SqlEngine {
-  constructor(psqlConnectionPool) {
+  constructor(psqlConnectionPool, shouldListenForDbTriggers = false) {
     super();
     this.psqlConnectionPool = psqlConnectionPool;
+    this.setupPgReturnTypes();
+    if (shouldListenForDbTriggers) {
+      this.setupTriggerListeners = this.listenForDbTriggers();
+    }
   }
-  async diffDatabaseToSchema(schema) {
-    console.log(schema);
-    return Promise.resolve("");
+  async close() {
+    if (this.triggerClient) {
+      await this.triggerClient.end();
+    }
+  }
+  setupPgReturnTypes() {
+    const TIMESTAMPTZ_OID = 1184;
+    types.setTypeParser(TIMESTAMPTZ_OID, (val) => {
+      return val === null ? null : new Date(val).toISOString();
+    });
+    const BIGINT_OID = 20;
+    types.setTypeParser(BIGINT_OID, (val) => {
+      return val === null ? null : Number(val);
+    });
+  }
+  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: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
+    });
+    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 = import_core_utils5.ObjectUtils.safeParse(msg.payload);
+        await this.handleTrigger(payload, msg.channel.toUpperCase());
+      }
+    });
+  }
+  async handleTrigger(payload, mutationType) {
+    if (payload.queryMetadata && payload.queryMetadata.connectionInstanceId === this.psqlConnectionPool.instanceId) {
+      await eventManager_default.fireActionFromDbTrigger({ queryMetadata: payload.queryMetadata, mutationType }, payload);
+    }
+  }
+  async createDatabaseFromSchema(schema, connection) {
+    const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
+    await connection.runQuery(sqlFullStatement, [], systemUser);
+    return sqlFullStatement;
   }
   generateDatabaseSchemaFromSchema(schema) {
-    console.log(schema);
-    return "";
+    const sqlStatements = [];
+    const indexes = [];
+    const triggers = [];
+    for (const table of schema.database) {
+      if (table.notify) {
+        triggers.push(this.createInsertTriggers(table.name, table.notify));
+        triggers.push(this.createUpdateTrigger(table.name, table.notify));
+        triggers.push(this.createDeleteTrigger(table.name, table.notify));
+      }
+      let sql = `CREATE TABLE "${table.name}"
+					   ( `;
+      const tableColumns = [];
+      for (const column of table.columns) {
+        let columnSql = "";
+        columnSql += `	"${column.name}" ${this.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 ";
+          indexes.push(
+            `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}" (${index.columns.map((item) => {
+              return `"${item}" ${index.order}`;
+            }).join(", ")});`
+          );
+        }
+      }
+      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 getScratchPool() {
+    var _a2, _b;
+    const scratchDbExists = await this.psqlConnectionPool.runQuery(
+      `SELECT *
+             FROM pg_database
+             WHERE datname = '${this.psqlConnectionPool.poolConfig.database}_scratch';`,
+      [],
+      systemUser
+    );
+    if (scratchDbExists.length === 0) {
+      await this.psqlConnectionPool.runQuery(
+        `CREATE DATABASE ${this.psqlConnectionPool.poolConfig.database}_scratch;`,
+        [],
+        systemUser
+      );
+    }
+    const scratchPool = new PsqlPool({
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port,
+      user: this.psqlConnectionPool.poolConfig.user,
+      database: this.psqlConnectionPool.poolConfig.database + "_scratch",
+      password: this.psqlConnectionPool.poolConfig.password,
+      max: this.psqlConnectionPool.poolConfig.max,
+      idleTimeoutMillis: this.psqlConnectionPool.poolConfig.idleTimeoutMillis,
+      connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
+    });
+    await scratchPool.runQuery(`DROP SCHEMA public CASCADE;`, [], systemUser);
+    await scratchPool.runQuery(
+      `CREATE SCHEMA public AUTHORIZATION ${this.psqlConnectionPool.poolConfig.user};`,
+      [],
+      systemUser
+    );
+    const schemaComment = await this.psqlConnectionPool.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 ((_a2 = schemaComment[0]) == null ? void 0 : _a2.description) {
+      await scratchPool.runQuery(
+        `COMMENT ON SCHEMA public IS '${(_b = schemaComment[0]) == null ? void 0 : _b.description}';`,
+        [],
+        systemUser
+      );
+    }
+    return scratchPool;
+  }
+  async diffDatabaseToSchema(schema) {
+    const scratchPool = await this.getScratchPool();
+    await this.createDatabaseFromSchema(schema, scratchPool);
+    const originalClient = new Client({
+      database: this.psqlConnectionPool.poolConfig.database,
+      user: this.psqlConnectionPool.poolConfig.user,
+      password: this.psqlConnectionPool.poolConfig.password,
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port
+    });
+    const scratchClient = new Client({
+      database: this.psqlConnectionPool.poolConfig.database + "_scratch",
+      user: this.psqlConnectionPool.poolConfig.user,
+      password: this.psqlConnectionPool.poolConfig.password,
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port
+    });
+    const promises = [originalClient.connect(), scratchClient.connect()];
+    await Promise.all(promises);
+    const infoPromises = [(0, import_pg_info.default)({ client: originalClient }), (0, import_pg_info.default)({ client: scratchClient })];
+    const [info1, info2] = await Promise.all(infoPromises);
+    const diff = (0, import_pg_diff_sync.default)(info1, info2);
+    const endPromises = [originalClient.end(), scratchClient.end()];
+    await Promise.all(endPromises);
+    return diff.join("\n");
   }
   createNestedSelect(req, schema, item, routeData, userRole, sqlParams) {
     if (!item.subquery) return "";
@@ -1464,8 +2172,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,
@@ -1474,7 +2181,7 @@ var PsqlEngine = class extends SqlEngine {
         return;
       }
       if (nestedItem.subquery) {
-        return `"${nestedItem.name}", ${this.createNestedSelect(
+        return `'${nestedItem.name}', ${this.createNestedSelect(
           // recursion
           req,
           schema,
@@ -1485,7 +2192,7 @@ var PsqlEngine = class extends SqlEngine {
         )}`;
       }
       return `'${nestedItem.name}', ${escapeColumnName(nestedItem.selector)}`;
-    }).filter(Boolean).join(",")}
+    }).filter(Boolean).join(", ")}
 						)) 
 						FROM
 							"${item.subquery.table}"
@@ -1500,16 +2207,19 @@ var PsqlEngine = class extends SqlEngine {
       parameterObj[assignment.name] = this.replaceParamKeywords(assignment.value, routeData, req, sqlParams);
     });
     const query = insertObjectQuery(routeData.table, __spreadValues(__spreadValues({}, req.data), parameterObj));
-    const createdItem = await this.psqlConnectionPool.queryOne(query, sqlParams, req.requesterDetails);
-    const insertId = createdItem == null ? void 0 : createdItem.id;
-    const whereData = [
-      {
-        tableName: routeData.table,
-        value: insertId,
-        columnName: "id",
-        operator: "="
-      }
-    ];
+    const createdItem = await this.psqlConnectionPool.queryOne(
+      query,
+      sqlParams,
+      req.requesterDetails
+    );
+    const insertId = createdItem.id;
+    const whereId = {
+      tableName: routeData.table,
+      value: insertId,
+      columnName: "id",
+      operator: "="
+    };
+    const whereData = [whereId];
     req.data = { id: insertId };
     return this.executeGetRequest(req, __spreadProps(__spreadValues({}, routeData), { where: whereData }), schema);
   }
@@ -1528,7 +2238,9 @@ var PsqlEngine = class extends SqlEngine {
     let selectStatement = "SELECT \n";
     selectStatement += `	${selectColumns.map((item) => {
       if (item.subquery) {
-        return `${this.createNestedSelect(req, schema, item, routeData, userRole, sqlParams)} AS ${item.name}`;
+        return `${this.createNestedSelect(req, schema, item, routeData, userRole, sqlParams)} AS ${escapeColumnName(
+          item.name
+        )}`;
       }
       return `${escapeColumnName(item.selector)} AS ${escapeColumnName(item.name)}`;
     }).join(",\n	")}
@@ -1561,29 +2273,31 @@ var PsqlEngine = class extends SqlEngine {
       );
     } else if (routeData.type === "PAGED") {
       const data = req.data;
-      const pageResults = await this.psqlConnectionPool.runQuery(
-        `${selectStatement}${sqlStatement}${groupByOrderByStatement} LIMIT ? OFFSET ?;SELECT COUNT(${routeData.groupBy ? `DISTINCT ${routeData.groupBy.tableName}.${routeData.groupBy.columnName}` : "*"}) AS total
-${sqlStatement};`,
-        [
-          ...sqlParams,
-          data.perPage || DEFAULT_PAGED_PER_PAGE_NUMBER,
-          (data.page - 1) * data.perPage || DEFAULT_PAGED_PAGE_NUMBER,
-          ...sqlParams
-        ],
+      const pagePromise = this.psqlConnectionPool.runQuery(
+        `${selectStatement}${sqlStatement}${groupByOrderByStatement}` + SQL`LIMIT ${data.perPage || DEFAULT_PAGED_PER_PAGE_NUMBER} OFFSET ${(data.page - 1) * data.perPage || DEFAULT_PAGED_PAGE_NUMBER};`,
+        sqlParams,
+        req.requesterDetails
+      );
+      const totalQuery = `SELECT COUNT(${routeData.groupBy ? `DISTINCT ${routeData.groupBy.tableName}.${routeData.groupBy.columnName}` : "*"}) AS total
+ ${sqlStatement};`;
+      const totalPromise = this.psqlConnectionPool.runQuery(
+        totalQuery,
+        sqlParams,
         req.requesterDetails
       );
+      const [pageResults, totalResponse] = await Promise.all([pagePromise, totalPromise]);
       let total = 0;
-      if (import_core_utils5.ObjectUtils.isArrayWithData(pageResults)) {
-        total = pageResults[1][0].total;
+      if (import_core_utils5.ObjectUtils.isArrayWithData(totalResponse)) {
+        total = totalResponse[0].total;
       }
-      return { data: pageResults[0], total };
+      return { data: pageResults, total };
     } else {
       throw new RsError("UNKNOWN_ERROR", "Unknown route type.");
     }
   }
   async executeUpdateRequest(req, routeData, schema) {
     const sqlParams = [];
-    const _a = req.body, { id } = _a, bodyNoId = __objRest(_a, ["id"]);
+    const _a2 = req.body, { id } = _a2, bodyNoId = __objRest(_a2, ["id"]);
     const table = schema.database.find((item) => {
       return item.name === routeData.table;
     });
@@ -1615,10 +2329,12 @@ ${sqlStatement};`,
       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;
   }
@@ -1681,38 +2397,37 @@ ${sqlStatement};`,
         );
       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) ? `(${replacedValue})` : replacedValue}
 `;
     });
     const data = req.data;
     if (routeData.type === "PAGED" && !!(data == null ? void 0 : data.filter)) {
       let statement = data.filter.replace(/\$[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
-        var _a;
+        var _a2;
         const requestParam = routeData.request.find((item) => {
           return item.name === value.replace("$", "");
         });
         if (!requestParam)
           throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
-        return ((_a = data[requestParam.name]) == null ? void 0 : _a.toString()) || "";
+        return ((_a2 = data[requestParam.name]) == null ? void 0 : _a2.toString()) || "";
       });
       statement = statement.replace(/#[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
-        var _a;
+        var _a2;
         const requestParam = routeData.request.find((item) => {
           return item.name === value.replace("#", "");
         });
         if (!requestParam)
           throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
-        return ((_a = data[requestParam.name]) == null ? void 0 : _a.toString()) || "";
+        return ((_a2 = data[requestParam.name]) == null ? void 0 : _a2.toString()) || "";
       });
       statement = filterPsqlParser_default.parse(statement);
       if (whereClause.startsWith("WHERE")) {
@@ -1725,82 +2440,259 @@ ${sqlStatement};`,
     }
     return whereClause;
   }
-};
+  createUpdateTrigger(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;
 
-// src/restura/sql/PsqlPool.ts
-var import_pg = __toESM(require("pg"));
-var import_pg_format2 = __toESM(require("pg-format"));
-var { Pool } = import_pg.default;
-var PsqlPool = class {
-  constructor(poolConfig) {
-    this.poolConfig = poolConfig;
-    this.pool = new Pool(poolConfig);
-    this.queryOne("SELECT NOW();", [], { isSystemUser: true, role: "", host: "localhost", ipAddress: "" }).then(() => {
-      logger.info("Connected to PostgreSQL database");
-    }).catch((error) => {
-      logger.error("Error connecting to database", error);
-      process.exit(1);
-    });
-  }
-  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  async queryOne(query, options, requesterDetails) {
-    const formattedQuery = questionMarksToOrderedParams(query);
-    this.logSqlStatement(formattedQuery, options, requesterDetails);
-    try {
-      const response = await this.pool.query(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];
-    } catch (error) {
-      console.error(error, query, options);
-      if (RsError.isRsError(error)) throw error;
-      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
-        throw new RsError("DUPLICATE", error.message);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
+	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;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+	AFTER UPDATE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+`;
     }
-  }
-  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  async runQuery(query, options, requesterDetails) {
-    const formattedQuery = questionMarksToOrderedParams(query);
-    this.logSqlStatement(formattedQuery, options, requesterDetails);
-    const queryUpdated = query.replace(/[\t\n]/g, " ");
-    console.log(queryUpdated, options);
-    try {
-      const response = await this.pool.query(formattedQuery, options);
-      return response.rows;
-    } catch (error) {
-      console.error(error, query, options);
-      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
-        throw new RsError("DUPLICATE", error.message);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    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;
+
+	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;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+	AFTER UPDATE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+		`;
+  }
+  createDeleteTrigger(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;
+
+	PERFORM pg_notify(
+		'delete',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'deletedId', OLD.id,
+						'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();
+`;
     }
-  }
-  logSqlStatement(query, options, requesterDetails, prefix = "") {
-    if (logger.level !== "silly") return;
-    let sqlStatement = "";
-    if (options.length === 0) {
-      sqlStatement = query;
-    } else {
-      let stringIndex = 0;
-      sqlStatement = query.replace(/\$\d+/g, () => {
-        const value = options[stringIndex++];
-        if (typeof value === "number") return value.toString();
-        return import_pg_format2.default.literal(value);
-      });
+    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 NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_delete"
+	AFTER DELETE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_delete();
+		`;
+  }
+  createInsertTriggers(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;
+
+	PERFORM pg_notify(
+		'insert',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'insertedId', NEW.id,
+						'record', NEW
+		)::text
+		);
+
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_insert"
+	AFTER INSERT ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+`;
     }
-    let initiator = "Anonymous";
-    if ("userId" in requesterDetails && requesterDetails.userId)
-      initiator = `User Id (${requesterDetails.userId.toString()})`;
-    if ("isSystemUser" in requesterDetails && requesterDetails.isSystemUser) initiator = "SYSTEM";
-    logger.silly(`${prefix}query by ${initiator}, Query ->
- ${sqlStatement}`);
+    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;
+
+	PERFORM pg_notify(
+		'insert',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'insertedId', NEW.id,
+						'record', json_build_object(
+							${notifyColumnNewBuildString}
+						)
+		)::text
+		);
+
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_insert"
+	AFTER INSERT ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+`;
+  }
+  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;
+  }
+};
+
+// src/restura/utils/TempCache.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_core_utils6 = require("@redskytech/core-utils");
+var import_internal3 = require("@restura/internal");
+var import_bluebird3 = __toESM(require("bluebird"));
+var os2 = __toESM(require("os"));
+var TempCache = class {
+  constructor(location) {
+    this.maxDurationDays = 7;
+    this.location = location || os2.tmpdir();
+    import_internal3.FileUtils.ensureDir(this.location).catch((e) => {
+      throw e;
+    });
+  }
+  async cleanup() {
+    const fileList = await import_fs3.default.promises.readdir(this.location);
+    await import_bluebird3.default.map(
+      fileList,
+      async (file) => {
+        const fullFilePath = import_path4.default.join(this.location, file);
+        const fileStats = await import_fs3.default.promises.stat(fullFilePath);
+        if (import_core_utils6.DateUtils.daysBetweenStartAndEndDates(new Date(fileStats.mtimeMs), /* @__PURE__ */ new Date()) > this.maxDurationDays) {
+          logger.info(`Deleting old temp file: ${file}`);
+          await import_fs3.default.promises.unlink(fullFilePath);
+        }
+      },
+      { concurrency: 10 }
+    );
   }
 };
 
 // src/restura/restura.ts
-var { types } = import_pg2.default;
 var ResturaEngine = class {
   constructor() {
     this.publicEndpoints = {
@@ -1818,10 +2710,11 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the initialization is complete.
    */
   async init(app, authenticationHandler, psqlConnectionPool) {
-    this.resturaConfig = import_internal2.config.validate("restura", resturaConfigSchema);
+    this.resturaConfig = import_internal4.config.validate("restura", resturaConfigSchema);
+    this.multerCommonUpload = getMulterUpload(this.resturaConfig.fileTempCachePath);
+    new TempCache(this.resturaConfig.fileTempCachePath);
     this.psqlConnectionPool = psqlConnectionPool;
-    this.psqlEngine = new PsqlEngine(this.psqlConnectionPool);
-    setupPgReturnTypes();
+    this.psqlEngine = new PsqlEngine(this.psqlConnectionPool, true);
     await customApiFactory_default.loadApiFiles(this.resturaConfig.customApiFolderPath);
     this.authenticationHandler = authenticationHandler;
     app.use((0, import_compression.default)());
@@ -1885,10 +2778,7 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the API has been successfully generated and written to the output file.
    */
   async generateApiFromSchema(outputFile, providedSchema) {
-    import_fs3.default.writeFileSync(
-      outputFile,
-      await apiGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
-    );
+    import_fs4.default.writeFileSync(outputFile, await apiGenerator(providedSchema));
   }
   /**
    * Generates a model from the provided schema and writes it to the specified output file.
@@ -1898,10 +2788,15 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the model has been successfully written to the output file.
    */
   async generateModelFromSchema(outputFile, providedSchema) {
-    import_fs3.default.writeFileSync(
-      outputFile,
-      await modelGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
-    );
+    import_fs4.default.writeFileSync(outputFile, await modelGenerator(providedSchema));
+  }
+  /**
+   * Generates the ambient module declaration for Restura global types and writes it to the specified output file.
+   * These types are used sometimes in the CustomTypes
+   * @param outputFile
+   */
+  generateResturaGlobalTypes(outputFile) {
+    import_fs4.default.writeFileSync(outputFile, resturaGlobalTypesGenerator());
   }
   /**
    * Retrieves the latest file system schema for Restura.
@@ -1910,12 +2805,12 @@ var ResturaEngine = class {
    * @throws {Error} If the schema file is missing or the schema is not valid.
    */
   async getLatestFileSystemSchema() {
-    if (!import_fs3.default.existsSync(this.resturaConfig.schemaFilePath)) {
+    if (!import_fs4.default.existsSync(this.resturaConfig.schemaFilePath)) {
       logger.error(`Missing restura schema file, expected path: ${this.resturaConfig.schemaFilePath}`);
       throw new Error("Missing restura schema file");
     }
-    const schemaFileData = import_fs3.default.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
-    const schema = import_core_utils6.ObjectUtils.safeParse(schemaFileData);
+    const schemaFileData = import_fs4.default.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
+    const schema = import_core_utils7.ObjectUtils.safeParse(schemaFileData);
     const isValid = await isSchemaValid(schema);
     if (!isValid) {
       logger.error("Schema is not valid");
@@ -1923,28 +2818,6 @@ var ResturaEngine = class {
     }
     return schema;
   }
-  /**
-   * Asynchronously generates and retrieves hashes for the provided schema and related generated files.
-   *
-   * @param providedSchema - The schema for which hashes need to be generated.
-   * @returns A promise that resolves to an object containing:
-   * - `schemaHash`: The hash of the provided schema.
-   * - `apiCreatedSchemaHash`: The hash extracted from the generated `api.d.ts` file.
-   * - `modelCreatedSchemaHash`: The hash extracted from the generated `models.d.ts` file.
-   */
-  async getHashes(providedSchema) {
-    var _a, _b, _c, _d;
-    const schemaHash = await this.generateHashForSchema(providedSchema);
-    const apiFile = import_fs3.default.readFileSync(import_path3.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const apiCreatedSchemaHash = (_b = (_a = apiFile.toString().match(/\((.*)\)/)) == null ? void 0 : _a[1]) != null ? _b : "";
-    const modelFile = import_fs3.default.readFileSync(import_path3.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
-    const modelCreatedSchemaHash = (_d = (_c = modelFile.toString().match(/\((.*)\)/)) == null ? void 0 : _c[1]) != null ? _d : "";
-    return {
-      schemaHash,
-      apiCreatedSchemaHash,
-      modelCreatedSchemaHash
-    };
-  }
   async reloadEndpoints() {
     this.schema = await this.getLatestFileSystemSchema();
     this.customTypeValidation = customTypeValidationGenerator(this.schema);
@@ -1973,30 +2846,10 @@ var ResturaEngine = class {
     logger.info(`Restura loaded (${routeCount}) endpoint${routeCount > 1 ? "s" : ""}`);
   }
   async validateGeneratedTypesFolder() {
-    if (!import_fs3.default.existsSync(this.resturaConfig.generatedTypesPath)) {
-      import_fs3.default.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
-    }
-    const hasApiFile = import_fs3.default.existsSync(import_path3.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const hasModelsFile = import_fs3.default.existsSync(import_path3.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
-    if (!hasApiFile) {
-      await this.generateApiFromSchema(import_path3.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
-    }
-    if (!hasModelsFile) {
-      await this.generateModelFromSchema(
-        import_path3.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
-        this.schema
-      );
-    }
-    const hashes = await this.getHashes(this.schema);
-    if (hashes.schemaHash !== hashes.apiCreatedSchemaHash) {
-      await this.generateApiFromSchema(import_path3.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
-    }
-    if (hashes.schemaHash !== hashes.modelCreatedSchemaHash) {
-      await this.generateModelFromSchema(
-        import_path3.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
-        this.schema
-      );
+    if (!import_fs4.default.existsSync(this.resturaConfig.generatedTypesPath)) {
+      import_fs4.default.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
     }
+    this.updateTypes();
   }
   resturaAuthentication(req, res, next) {
     if (req.headers["x-auth-token"] !== this.resturaConfig.authToken) res.status(401).send("Unauthorized");
@@ -2004,7 +2857,7 @@ var ResturaEngine = class {
   }
   async previewCreateSchema(req, res) {
     try {
-      const schemaDiff = { commands: "", endPoints: [], globalParams: [], roles: [], customTypes: false };
+      const schemaDiff = await compareSchema_default.diffSchema(req.data, this.schema, this.psqlEngine);
       res.send({ data: schemaDiff });
     } catch (err) {
       res.status(400).send(err);
@@ -2012,7 +2865,7 @@ var ResturaEngine = class {
   }
   async updateSchema(req, res) {
     try {
-      this.schema = req.data;
+      this.schema = sortObjectKeysAlphabetically(req.data);
       await this.storeFileSystemSchema();
       await this.reloadEndpoints();
       await this.updateTypes();
@@ -2023,11 +2876,12 @@ var ResturaEngine = class {
     }
   }
   async updateTypes() {
-    await this.generateApiFromSchema(import_path3.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+    await this.generateApiFromSchema(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     await this.generateModelFromSchema(
-      import_path3.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+      import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
       this.schema
     );
+    this.generateResturaGlobalTypes(import_path5.default.join(this.resturaConfig.generatedTypesPath, "restura.d.ts"));
   }
   async getSchema(req, res) {
     res.send({ data: this.schema });
@@ -2035,19 +2889,38 @@ var ResturaEngine = class {
   async getSchemaAndTypes(req, res) {
     try {
       const schema = await this.getLatestFileSystemSchema();
-      const schemaHash = await this.generateHashForSchema(schema);
-      const apiText = await apiGenerator(schema, schemaHash);
-      const modelsText = await modelGenerator(schema, schemaHash);
+      const apiText = await apiGenerator(schema);
+      const modelsText = await modelGenerator(schema);
       res.send({ schema, api: apiText, models: modelsText });
     } catch (err) {
       res.status(400).send({ error: err });
     }
   }
+  async getMulterFilesIfAny(req, res, routeData) {
+    var _a2;
+    if (!((_a2 = req.header("content-type")) == null ? void 0 : _a2.includes("multipart/form-data"))) return;
+    if (!this.isCustomRoute(routeData)) return;
+    if (!routeData.fileUploadType) {
+      throw new RsError("BAD_REQUEST", "File upload type not defined for route");
+    }
+    const multerFileUploadFunction = routeData.fileUploadType === "MULTIPLE" ? this.multerCommonUpload.array("files") : this.multerCommonUpload.single("file");
+    return new Promise((resolve2, reject) => {
+      multerFileUploadFunction(req, res, (err) => {
+        if (err) {
+          logger.warn("Multer error: " + err);
+          reject(err);
+        }
+        if (req.body["data"]) req.body = JSON.parse(req.body["data"]);
+        resolve2();
+      });
+    });
+  }
   async executeRouteLogic(req, res, next) {
     try {
       const routeData = this.getRouteData(req.method, req.baseUrl, req.path);
       this.validateAuthorization(req, routeData);
-      validateRequestParams(req, routeData, this.customTypeValidation);
+      await this.getMulterFilesIfAny(req, res, routeData);
+      requestValidator(req, routeData, this.customTypeValidation);
       if (this.isCustomRoute(routeData)) {
         await this.runCustomRouteLogic(req, res, routeData);
         return;
@@ -2072,33 +2945,21 @@ var ResturaEngine = class {
     let domain = routeData.path.split("/")[1];
     domain = domain.split("-").reduce((acc, value, index) => {
       if (index === 0) acc = value;
-      else acc += import_core_utils6.StringUtils.capitalizeFirst(value);
+      else acc += import_core_utils7.StringUtils.capitalizeFirst(value);
       return acc;
     }, "");
-    const customApiName = `${import_core_utils6.StringUtils.capitalizeFirst(domain)}Api${import_core_utils6.StringUtils.capitalizeFirst(version)}`;
+    const customApiName = `${import_core_utils7.StringUtils.capitalizeFirst(domain)}Api${import_core_utils7.StringUtils.capitalizeFirst(version)}`;
     const customApi = customApiFactory_default.getCustomApi(customApiName);
     if (!customApi) throw new RsError("NOT_FOUND", `API domain ${domain}-${version} not found`);
     const functionName = `${routeData.method.toLowerCase()}${routeData.path.replace(new RegExp("-", "g"), "/").split("/").reduce((acc, cur) => {
       if (cur === "") return acc;
-      return acc + import_core_utils6.StringUtils.capitalizeFirst(cur);
+      return acc + import_core_utils7.StringUtils.capitalizeFirst(cur);
     }, "")}`;
     const customFunction = customApi[functionName];
-    if (!customFunction) throw new RsError("NOT_FOUND", `API path ${routeData.path} not implemented`);
+    if (!customFunction)
+      throw new RsError("NOT_FOUND", `API path ${routeData.path} not implemented ${functionName}`);
     await customFunction(req, res, routeData);
   }
-  async generateHashForSchema(providedSchema) {
-    const schemaPrettyStr = await prettier3.format(JSON.stringify(providedSchema), __spreadValues({
-      parser: "json"
-    }, {
-      trailingComma: "none",
-      tabWidth: 4,
-      useTabs: true,
-      endOfLine: "lf",
-      printWidth: 120,
-      singleQuote: true
-    }));
-    return (0, import_crypto.createHash)("sha256").update(schemaPrettyStr).digest("hex");
-  }
   async storeFileSystemSchema() {
     const schemaPrettyStr = await prettier3.format(JSON.stringify(this.schema), __spreadValues({
       parser: "json"
@@ -2110,7 +2971,7 @@ var ResturaEngine = class {
       printWidth: 120,
       singleQuote: true
     }));
-    import_fs3.default.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
+    import_fs4.default.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
   }
   resetPublicEndpoints() {
     this.publicEndpoints = {
@@ -2127,13 +2988,13 @@ var ResturaEngine = class {
     if (!routeData.roles.includes(role))
       throw new RsError("UNAUTHORIZED", "Not authorized to access this endpoint");
   }
-  getRouteData(method, baseUrl, path4) {
+  getRouteData(method, baseUrl, path5) {
     const endpoint = this.schema.endpoints.find((item) => {
       return item.baseUrl === baseUrl;
     });
     if (!endpoint) throw new RsError("NOT_FOUND", "Route not found");
     const route = endpoint.routes.find((item) => {
-      return item.method === method && item.path === path4;
+      return item.method === method && item.path === path5;
     });
     if (!route) throw new RsError("NOT_FOUND", "Route not found");
     return route;
@@ -2154,6 +3015,9 @@ __decorateClass([
 __decorateClass([
   boundMethod
 ], ResturaEngine.prototype, "getSchemaAndTypes", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "getMulterFilesIfAny", 1);
 __decorateClass([
   boundMethod
 ], ResturaEngine.prototype, "executeRouteLogic", 1);
@@ -2163,25 +3027,55 @@ __decorateClass([
 __decorateClass([
   boundMethod
 ], ResturaEngine.prototype, "runCustomRouteLogic", 1);
-var setupPgReturnTypes = () => {
-  const TIMESTAMPTZ_OID = 1184;
-  types.setTypeParser(TIMESTAMPTZ_OID, (val) => {
-    return val === null ? null : new Date(val).toISOString();
-  });
-  const BIGINT_OID = 20;
-  types.setTypeParser(BIGINT_OID, (val) => {
-    return val === null ? null : Number(val);
-  });
-};
-setupPgReturnTypes();
 var restura = new ResturaEngine();
+
+// src/restura/sql/PsqlTransaction.ts
+var import_pg3 = __toESM(require("pg"));
+var { Client: Client2 } = import_pg3.default;
+var PsqlTransaction = class extends PsqlConnection {
+  constructor(clientConfig, instanceId) {
+    super(instanceId);
+    this.clientConfig = clientConfig;
+    this.client = new Client2(clientConfig);
+    this.connectPromise = this.client.connect();
+    this.beginTransactionPromise = this.beginTransaction();
+  }
+  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);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HtmlStatusCodes,
+  PsqlConnection,
+  PsqlEngine,
   PsqlPool,
+  PsqlTransaction,
   RsError,
   SQL,
   escapeColumnName,
+  eventManager,
+  filterPsqlParser,
   insertObjectQuery,
   isValueNumber,
   logger,