@restura/core 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/index.js

@@ -1,8 +1,39 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,21 +46,2869 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  isEven: () => isEven
+  HtmlStatusCodes: () => HtmlStatusCodes,
+  PsqlConnection: () => PsqlConnection,
+  PsqlEngine: () => PsqlEngine,
+  PsqlPool: () => PsqlPool,
+  PsqlTransaction: () => PsqlTransaction,
+  RsError: () => RsError,
+  SQL: () => SQL,
+  escapeColumnName: () => escapeColumnName,
+  eventManager: () => eventManager_default,
+  insertObjectQuery: () => insertObjectQuery,
+  isValueNumber: () => isValueNumber2,
+  logger: () => logger,
+  questionMarksToOrderedParams: () => questionMarksToOrderedParams,
+  restura: () => restura,
+  updateObjectQuery: () => updateObjectQuery
 });
 module.exports = __toCommonJS(src_exports);
+
+// src/logger/logger.ts
 var import_internal = require("@restura/internal");
-function isEven(value) {
-  (0, import_internal.log)("isEven called");
-  return value % 2 === 0;
+var import_winston = __toESM(require("winston"));
+var import_logform = require("logform");
+
+// src/config.schema.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 _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_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() + customApiFolderPath),
+  generatedTypesPath: import_zod.z.string().default(process.cwd() + "/src/@types"),
+  fileTempCachePath: import_zod.z.string().optional()
+});
+
+// src/logger/logger.ts
+var loggerConfig = import_internal.config.validate("logger", loggerConfigSchema);
+var consoleFormat = import_logform.format.combine(
+  import_logform.format.timestamp({
+    format: "YYYY-MM-DD HH:mm:ss.sss"
+  }),
+  import_logform.format.errors({ stack: true }),
+  import_logform.format.padLevels(),
+  import_logform.format.colorize({ all: true }),
+  import_logform.format.printf((info) => {
+    return `[${info.timestamp}] ${info.level}  ${info.message}`;
+  })
+);
+var logger = import_winston.default.createLogger({
+  level: loggerConfig.level,
+  format: import_logform.format.combine(
+    import_logform.format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss.sss"
+    }),
+    import_logform.format.errors({ stack: true }),
+    import_logform.format.json()
+  ),
+  //defaultMeta: { service: 'user-service' },
+  transports: [
+    //
+    // - Write to all logs with level `info` and below to `combined.log`
+    // - Write all logs error (and below) to `error.log`.
+    // - Write all logs to standard out.
+    //
+    // new winston.transports.File({ filename: 'error.log', level: 'error' }),
+    // new winston.transports.File({ filename: 'combined.log' }),
+    new import_winston.default.transports.Console({ format: consoleFormat })
+  ]
+});
+
+// src/restura/errors.ts
+var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
+  HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HtmlStatusCodes2[HtmlStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HtmlStatusCodes2[HtmlStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HtmlStatusCodes2[HtmlStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HtmlStatusCodes2[HtmlStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
+  HtmlStatusCodes2[HtmlStatusCodes2["VERSION_OUT_OF_DATE"] = 418] = "VERSION_OUT_OF_DATE";
+  HtmlStatusCodes2[HtmlStatusCodes2["SERVER_ERROR"] = 500] = "SERVER_ERROR";
+  HtmlStatusCodes2[HtmlStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HtmlStatusCodes2[HtmlStatusCodes2["NETWORK_CONNECT_TIMEOUT"] = 599] = "NETWORK_CONNECT_TIMEOUT";
+  return HtmlStatusCodes2;
+})(HtmlStatusCodes || {});
+var RsError = class _RsError {
+  constructor(errCode, message) {
+    this.err = errCode;
+    this.msg = message || "";
+    this.status = _RsError.htmlStatus(errCode);
+    this.stack = new Error().stack || "";
+  }
+  static htmlStatus(code) {
+    return htmlStatusMap[code];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static isRsError(error) {
+    return error instanceof _RsError;
+  }
+};
+var htmlStatusMap = {
+  UNKNOWN_ERROR: 500 /* SERVER_ERROR */,
+  NOT_FOUND: 404 /* NOT_FOUND */,
+  EMAIL_TAKEN: 409 /* CONFLICT */,
+  FORBIDDEN: 403 /* FORBIDDEN */,
+  CONFLICT: 409 /* CONFLICT */,
+  UNAUTHORIZED: 401 /* UNAUTHORIZED */,
+  UPDATE_FORBIDDEN: 403 /* FORBIDDEN */,
+  CREATE_FORBIDDEN: 403 /* FORBIDDEN */,
+  DELETE_FORBIDDEN: 403 /* FORBIDDEN */,
+  DELETE_FAILURE: 500 /* SERVER_ERROR */,
+  BAD_REQUEST: 400 /* BAD_REQUEST */,
+  INVALID_TOKEN: 401 /* UNAUTHORIZED */,
+  INCORRECT_EMAIL_OR_PASSWORD: 401 /* UNAUTHORIZED */,
+  DUPLICATE_TOKEN: 409 /* CONFLICT */,
+  DUPLICATE_USERNAME: 409 /* CONFLICT */,
+  DUPLICATE_EMAIL: 409 /* CONFLICT */,
+  DUPLICATE: 409 /* CONFLICT */,
+  EMAIL_NOT_VERIFIED: 400 /* BAD_REQUEST */,
+  UPDATE_WITHOUT_ID: 400 /* BAD_REQUEST */,
+  CONNECTION_ERROR: 599 /* NETWORK_CONNECT_TIMEOUT */,
+  INVALID_PAYMENT: 403 /* FORBIDDEN */,
+  DECLINED_PAYMENT: 403 /* FORBIDDEN */,
+  INTEGRATION_ERROR: 500 /* SERVER_ERROR */,
+  CANNOT_RESERVE: 403 /* FORBIDDEN */,
+  REFUND_FAILURE: 403 /* FORBIDDEN */,
+  INVALID_INVOICE: 403 /* FORBIDDEN */,
+  INVALID_COUPON: 403 /* FORBIDDEN */,
+  SERVICE_UNAVAILABLE: 503 /* SERVICE_UNAVAILABLE */,
+  METHOD_UNALLOWED: 405 /* METHOD_NOT_ALLOWED */,
+  LOGIN_EXPIRED: 401 /* UNAUTHORIZED */,
+  THIRD_PARTY_ERROR: 400 /* BAD_REQUEST */,
+  ACCESS_DENIED: 403 /* FORBIDDEN */,
+  DATABASE_ERROR: 500 /* SERVER_ERROR */,
+  SCHEMA_ERROR: 500 /* SERVER_ERROR */
+};
+
+// 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 import_crypto2 = require("crypto");
+var express = __toESM(require("express"));
+var import_fs4 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_pg3 = __toESM(require("pg"));
+var prettier3 = __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"))
+      return "number";
+    if (type === "json") {
+      if (!value) return "object";
+      return value.split(",").map((val) => {
+        return val.replace(/['"]/g, "");
+      }).join(" | ");
+    }
+    if (type.startsWith("varchar") || type.indexOf("text") > -1 || type.startsWith("char") || type.indexOf("blob") > -1 || type.startsWith("binary"))
+      return "string";
+    if (type.startsWith("date") || type.startsWith("time")) return "string";
+    if (type.startsWith("enum")) return _SqlUtils.convertDatabaseEnumToStringUnion(value || type);
+    return "any";
+  }
+  static convertDatabaseEnumToStringUnion(type) {
+    return type.replace(/^enum\(|\)/g, "").split(",").map((value) => {
+      return `'${value.replace(/'/g, "")}'`;
+    }).join(" | ");
+  }
+};
+
+// src/restura/ResponseValidator.ts
+var ResponseValidator = class _ResponseValidator {
+  constructor(schema) {
+    this.database = schema.database;
+    this.rootMap = {};
+    for (const endpoint of schema.endpoints) {
+      const endpointMap = {};
+      for (const route of endpoint.routes) {
+        if (_ResponseValidator.isCustomRoute(route)) {
+          endpointMap[`${route.method}:${route.path}`] = { validator: "any" };
+          continue;
+        }
+        endpointMap[`${route.method}:${route.path}`] = this.getRouteResponseType(route);
+      }
+      const endpointUrl = endpoint.baseUrl.endsWith("/") ? endpoint.baseUrl.slice(0, -1) : endpoint.baseUrl;
+      this.rootMap[endpointUrl] = { validator: endpointMap };
+    }
+  }
+  validateResponseParams(data, endpointUrl, routeData) {
+    if (!this.rootMap) {
+      throw new RsError("BAD_REQUEST", "Cannot validate response without type maps");
+    }
+    const routeMap = this.rootMap[endpointUrl].validator[`${routeData.method}:${routeData.path}`];
+    data = this.validateAndCoerceMap("_base", data, routeMap);
+  }
+  getRouteResponseType(route) {
+    const map = {};
+    for (const field of route.response) {
+      map[field.name] = this.getFieldResponseType(field, route.table);
+    }
+    if (route.type === "PAGED") {
+      return {
+        validator: {
+          data: { validator: map, isArray: true },
+          total: { validator: "number" }
+        }
+      };
+    }
+    if (route.method === "DELETE") {
+      return {
+        validator: "boolean"
+      };
+    }
+    return { validator: map, isArray: route.type === "ARRAY" };
+  }
+  getFieldResponseType(field, tableName) {
+    if (field.selector) {
+      return this.getTypeFromTable(field.selector, tableName);
+    } else if (field.subquery) {
+      const table = this.database.find((t) => t.name == tableName);
+      if (!table) return { isArray: true, validator: "any" };
+      const isOptional = table.roles.length > 0;
+      const validator = {};
+      for (const prop of field.subquery.properties) {
+        validator[prop.name] = this.getFieldResponseType(prop, field.subquery.table);
+      }
+      return {
+        isArray: true,
+        isOptional,
+        validator
+      };
+    }
+    return { validator: "any" };
+  }
+  getTypeFromTable(selector, name) {
+    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 };
+    let validator = SqlUtils.convertDatabaseTypeToTypescript(
+      column.type,
+      column.value
+    );
+    if (!_ResponseValidator.validatorIsValidString(validator)) validator = this.parseValidationEnum(validator);
+    return {
+      validator,
+      isOptional: column.roles.length > 0 || column.isNullable
+    };
+  }
+  parseValidationEnum(validator) {
+    let terms = validator.split("|");
+    terms = terms.map((v) => v.replace(/'/g, "").trim());
+    return terms;
+  }
+  validateAndCoerceMap(name, value, { isOptional, isArray, validator }) {
+    if (validator === "any") return value;
+    const valueType = typeof value;
+    if (value == null) {
+      if (isOptional) return value;
+      throw new RsError("DATABASE_ERROR", `Response param (${name}) is required`);
+    }
+    if (isArray) {
+      if (!Array.isArray(value)) {
+        throw new RsError(
+          "DATABASE_ERROR",
+          `Response param (${name}) is a/an ${valueType} instead of an array`
+        );
+      }
+      value.forEach((v, i) => this.validateAndCoerceMap(`${name}[${i}]`, v, { validator }));
+      return value;
+    }
+    if (typeof validator === "string") {
+      if (validator === "boolean" && valueType === "number") {
+        if (value !== 0 && value !== 1)
+          throw new RsError("DATABASE_ERROR", `Response param (${name}) is of the wrong type (${valueType})`);
+        return value === 1;
+      } else if (validator === "string" && valueType === "string") {
+        if (typeof value === "string" && value.match(
+          /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.?\d*$|\d{2}:\d{2}:\d{2}.?\d*$|^\d{4}-\d{2}-\d{2}$/
+        )) {
+          const date = new Date(value);
+          if (date.toISOString() === "1970-01-01T00:00:00.000Z") return null;
+          const timezoneOffset = date.getTimezoneOffset() * 6e4;
+          return new Date(date.getTime() - timezoneOffset * 2).toISOString();
+        }
+        return value;
+      } else if (valueType === validator) {
+        return value;
+      } else if (valueType === "object") {
+        return value;
+      }
+      throw new RsError("DATABASE_ERROR", `Response param (${name}) is of the wrong type (${valueType})`);
+    }
+    if (Array.isArray(validator) && typeof value === "string") {
+      if (validator.includes(value)) return value;
+      throw new RsError("DATABASE_ERROR", `Response param (${name}) is not one of the enum options (${value})`);
+    }
+    if (valueType !== "object") {
+      throw new RsError("DATABASE_ERROR", `Response param (${name}) is of the wrong type (${valueType})`);
+    }
+    for (const prop in value) {
+      if (!validator[prop])
+        throw new RsError("DATABASE_ERROR", `Response param (${name}.${prop}) is not allowed`);
+    }
+    for (const prop in validator) {
+      value[prop] = this.validateAndCoerceMap(`${name}.${prop}`, value[prop], validator[prop]);
+    }
+    return value;
+  }
+  static isCustomRoute(route) {
+    return route.type === "CUSTOM_ONE" || route.type === "CUSTOM_ARRAY" || route.type === "CUSTOM_PAGED";
+  }
+  static validatorIsValidString(validator) {
+    return !validator.includes("|");
+  }
+};
+
+// src/restura/apiGenerator.ts
+var import_core_utils = require("@redskytech/core-utils");
+var import_prettier = __toESM(require("prettier"));
+var ApiTree = class _ApiTree {
+  constructor(namespace, database) {
+    this.database = database;
+    this.data = [];
+    this.namespace = namespace;
+    this.children = /* @__PURE__ */ new Map();
+  }
+  static createRootNode(database) {
+    return new _ApiTree(null, database);
+  }
+  static isRouteData(data) {
+    return data.method !== void 0;
+  }
+  static isEndpointData(data) {
+    return data.routes !== void 0;
+  }
+  addData(namespaces, route) {
+    if (import_core_utils.ObjectUtils.isEmpty(namespaces)) {
+      this.data.push(route);
+      return;
+    }
+    const childName = namespaces[0];
+    this.children.set(childName, this.children.get(childName) || new _ApiTree(childName, this.database));
+    this.children.get(childName).addData(namespaces.slice(1), route);
+  }
+  createApiModels() {
+    let result = "";
+    for (const child of this.children.values()) {
+      result += child.createApiModelImpl(true);
+    }
+    return result;
+  }
+  createApiModelImpl(isBase) {
+    let result = ``;
+    for (const data of this.data) {
+      if (_ApiTree.isEndpointData(data)) {
+        result += _ApiTree.generateEndpointComments(data);
+      }
+    }
+    result += isBase ? `
+			declare namespace ${this.namespace} {` : `
+			export namespace ${this.namespace} {`;
+    for (const data of this.data) {
+      if (_ApiTree.isRouteData(data)) {
+        result += this.generateRouteModels(data);
+      }
+    }
+    for (const child of this.children.values()) {
+      result += child.createApiModelImpl(false);
+    }
+    result += "}";
+    return result;
+  }
+  static generateEndpointComments(endpoint) {
+    return `
+		// ${endpoint.name}
+		// ${endpoint.description}`;
+  }
+  generateRouteModels(route) {
+    let modelString = ``;
+    modelString += `
+				// ${route.name}
+				// ${route.description}
+				export namespace ${import_core_utils.StringUtils.capitalizeFirst(route.method.toLowerCase())} {
+				  ${this.generateRequestParameters(route)}
+				  ${this.generateResponseParameters(route)}
+				}`;
+    return modelString;
+  }
+  generateRequestParameters(route) {
+    let modelString = ``;
+    if (ResponseValidator.isCustomRoute(route) && route.requestType) {
+      modelString += `
+				export type Req = CustomTypes.${route.requestType}`;
+      return modelString;
+    }
+    if (!route.request) return modelString;
+    modelString += `
+		 	export interface Req{
+		 					${route.request.map((p) => {
+      let requestType = "any";
+      const oneOfValidator = p.validator.find((v) => v.type === "ONE_OF");
+      const typeCheckValidator = p.validator.find((v) => v.type === "TYPE_CHECK");
+      if (oneOfValidator && import_core_utils.ObjectUtils.isArrayWithData(oneOfValidator.value)) {
+        requestType = oneOfValidator.value.map((v) => `'${v}'`).join(" | ");
+      } else if (typeCheckValidator) {
+        switch (typeCheckValidator.value) {
+          case "string":
+          case "number":
+          case "boolean":
+          case "string[]":
+          case "number[]":
+          case "any[]":
+            requestType = typeCheckValidator.value;
+            break;
+        }
+      }
+      return `'${p.name}'${p.required ? "" : "?"}:${requestType}${p.isNullable ? " | null" : ""}`;
+    }).join(";\n")}${import_core_utils.ObjectUtils.isArrayWithData(route.request) ? ";" : ""}
+		 `;
+    modelString += `}`;
+    return modelString;
+  }
+  generateResponseParameters(route) {
+    if (ResponseValidator.isCustomRoute(route)) {
+      if (["number", "string", "boolean"].includes(route.responseType))
+        return `export type Res = ${route.responseType}`;
+      else if (["CUSTOM_ARRAY", "CUSTOM_PAGED"].includes(route.type))
+        return `export type Res = CustomTypes.${route.responseType}[]`;
+      else return `export type Res = CustomTypes.${route.responseType}`;
+    }
+    return `export interface Res ${this.getFields(route.response)}`;
+  }
+  getFields(fields) {
+    const nameFields = fields.map((f) => this.getNameAndType(f));
+    const nested = `{
+			${nameFields.join(";\n	")}${import_core_utils.ObjectUtils.isArrayWithData(nameFields) ? ";" : ""}
+		}`;
+    return nested;
+  }
+  getNameAndType(p) {
+    let responseType = "any", isNullable = false, array = false;
+    if (p.selector) {
+      ({ responseType, isNullable } = this.getTypeFromTable(p.selector, p.name));
+    } else if (p.subquery) {
+      responseType = this.getFields(p.subquery.properties);
+      array = true;
+    }
+    return `${p.name}:${responseType}${array ? "[]" : ""}${isNullable ? " | null" : ""}`;
+  }
+  getTypeFromTable(selector, name) {
+    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("_");
+      tableName = tableAliasSplit[1];
+      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", isNullable: false };
+    return {
+      responseType: SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value),
+      isNullable: column.roles.length > 0 || column.isNullable
+    };
+  }
+};
+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 **/`;
+  const rootNamespace = ApiTree.createRootNode(schema.database);
+  for (const endpoint of schema.endpoints) {
+    const endpointNamespaces = pathToNamespaces(endpoint.baseUrl);
+    rootNamespace.addData(endpointNamespaces, endpoint);
+    for (const route of endpoint.routes) {
+      const fullNamespace = [...endpointNamespaces, ...pathToNamespaces(route.path)];
+      rootNamespace.addData(fullNamespace, route);
+    }
+  }
+  apiString += rootNamespace.createApiModels();
+  if (schema.customTypes.length > 0) {
+    apiString += `
+
+		declare namespace CustomTypes {
+			${schema.customTypes}
+		}`;
+  }
+  return import_prettier.default.format(apiString, __spreadValues({
+    parser: "typescript"
+  }, {
+    trailingComma: "none",
+    tabWidth: 4,
+    useTabs: true,
+    endOfLine: "lf",
+    printWidth: 120,
+    singleQuote: true
+  }));
+}
+
+// src/restura/customApiFactory.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_bluebird = __toESM(require("bluebird"));
+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_bluebird.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) {
+          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
+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"));
+function customTypeValidationGenerator(currentSchema) {
+  const schemaObject = {};
+  const customInterfaceNames = currentSchema.customTypes.match(new RegExp("(?<=interface\\s)(\\w+)|(?<=type\\s)(\\w+)", "g"));
+  if (!customInterfaceNames) return {};
+  const temporaryFile = import_tmp.default.fileSync({ mode: 420, prefix: "prefix-", postfix: ".ts" });
+  import_fs2.default.writeFileSync(temporaryFile.name, currentSchema.customTypes);
+  const compilerOptions = {
+    strictNullChecks: true,
+    skipLibCheck: true
+  };
+  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")
+    ],
+    compilerOptions
+  );
+  customInterfaceNames.forEach((item) => {
+    const ddlSchema = TJS.generateSchema(program, item, {
+      required: true
+    });
+    schemaObject[item] = ddlSchema || {};
+  });
+  temporaryFile.removeCallback();
+  return schemaObject;
+}
+
+// src/restura/middleware/addApiResponseFunctions.ts
+function addApiResponseFunctions(req, res, next) {
+  res.sendData = function(data, statusCode = 200) {
+    res.status(statusCode).send({ data });
+  };
+  res.sendNoWrap = function(dataNoWrap, statusCode = 200) {
+    res.status(statusCode).send(dataNoWrap);
+  };
+  res.sendPaginated = function(pagedData, statusCode = 200) {
+    res.status(statusCode).send({ data: pagedData.data, total: pagedData.total });
+  };
+  res.sendError = function(shortError, msg, htmlStatusCode, stack) {
+    if (htmlStatusCode === void 0) {
+      if (RsError.htmlStatus(shortError) !== void 0) {
+        htmlStatusCode = RsError.htmlStatus(shortError);
+      } else {
+        htmlStatusCode = 500;
+      }
+    }
+    const errorData = __spreadValues({
+      err: shortError,
+      msg
+    }, restura.resturaConfig.sendErrorStackTrace && stack ? { stack } : {});
+    res.status(htmlStatusCode).send(errorData);
+  };
+  next();
+}
+
+// src/restura/middleware/authenticateUser.ts
+function authenticateUser(applicationAuthenticateHandler) {
+  return (req, res, next) => {
+    applicationAuthenticateHandler(req, res, (userDetails) => {
+      req.requesterDetails = __spreadValues(__spreadValues({}, req.requesterDetails), userDetails);
+      next();
+    });
+  };
+}
+
+// src/restura/restura.schema.ts
+var import_zod3 = require("zod");
+
+// src/restura/types/validation.types.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({
+  type: import_zod2.z.enum(["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]),
+  value: validatorDataSchemeValue
+}).strict();
+
+// src/restura/restura.schema.ts
+var orderBySchema = import_zod3.z.object({
+  columnName: import_zod3.z.string(),
+  order: import_zod3.z.enum(["ASC", "DESC"]),
+  tableName: import_zod3.z.string()
+}).strict();
+var groupBySchema = import_zod3.z.object({
+  columnName: import_zod3.z.string(),
+  tableName: import_zod3.z.string()
+}).strict();
+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(),
+  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()
+}).strict();
+var assignmentDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  value: import_zod3.z.string()
+}).strict();
+var joinDataSchema = import_zod3.z.object({
+  table: import_zod3.z.string(),
+  localColumnName: import_zod3.z.string().optional(),
+  foreignColumnName: import_zod3.z.string().optional(),
+  custom: import_zod3.z.string().optional(),
+  type: import_zod3.z.enum(["LEFT", "INNER"]),
+  alias: import_zod3.z.string().optional()
+}).strict();
+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({
+  name: import_zod3.z.string(),
+  selector: import_zod3.z.string().optional(),
+  subquery: import_zod3.z.object({
+    table: import_zod3.z.string(),
+    joins: import_zod3.z.array(joinDataSchema),
+    where: import_zod3.z.array(whereDataSchema),
+    properties: import_zod3.z.array(import_zod3.z.lazy(() => responseDataSchema)),
+    // Explicit type for the lazy schema
+    groupBy: groupBySchema.optional(),
+    orderBy: orderBySchema.optional()
+  }).optional()
+}).strict();
+var routeDataBaseSchema = import_zod3.z.object({
+  method: import_zod3.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  path: import_zod3.z.string(),
+  roles: import_zod3.z.array(import_zod3.z.string())
+}).strict();
+var standardRouteSchema = routeDataBaseSchema.extend({
+  type: import_zod3.z.enum(["ONE", "ARRAY", "PAGED"]),
+  table: import_zod3.z.string(),
+  joins: import_zod3.z.array(joinDataSchema),
+  assignments: import_zod3.z.array(assignmentDataSchema),
+  where: import_zod3.z.array(whereDataSchema),
+  request: import_zod3.z.array(requestDataSchema),
+  response: import_zod3.z.array(responseDataSchema),
+  groupBy: groupBySchema.optional(),
+  orderBy: orderBySchema.optional()
+}).strict();
+var customRouteSchema = routeDataBaseSchema.extend({
+  type: import_zod3.z.enum(["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]),
+  responseType: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.enum(["string", "number", "boolean"])]),
+  requestType: import_zod3.z.string().optional(),
+  request: import_zod3.z.array(requestDataSchema).optional(),
+  table: import_zod3.z.undefined(),
+  joins: import_zod3.z.undefined(),
+  assignments: import_zod3.z.undefined(),
+  fileUploadType: import_zod3.z.enum(["SINGLE", "MULTIPLE"]).optional()
+}).strict();
+var postgresColumnNumericTypesSchema = import_zod3.z.enum([
+  "SMALLINT",
+  // 2 bytes, -32,768 to 32,767
+  "INTEGER",
+  // 4 bytes, -2,147,483,648 to 2,147,483,647
+  "BIGINT",
+  // 8 bytes, -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
+  "DECIMAL",
+  // user-specified precision, exact numeric
+  "NUMERIC",
+  // same as DECIMAL
+  "REAL",
+  // 4 bytes, 6 decimal digits precision (single precision)
+  "DOUBLE PRECISION",
+  // 8 bytes, 15 decimal digits precision (double precision)
+  "SERIAL",
+  // auto-incrementing integer
+  "BIGSERIAL"
+  // auto-incrementing big integer
+]);
+var postgresColumnStringTypesSchema = import_zod3.z.enum([
+  "CHAR",
+  // fixed-length, blank-padded
+  "VARCHAR",
+  // variable-length with limit
+  "TEXT",
+  // variable-length without limit
+  "BYTEA"
+  // binary data
+]);
+var postgresColumnDateTypesSchema = import_zod3.z.enum([
+  "DATE",
+  // calendar date (year, month, day)
+  "TIMESTAMP",
+  // both date and time (without time zone)
+  "TIMESTAMPTZ",
+  // both date and time (with time zone)
+  "TIME",
+  // time of day (without time zone)
+  "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.
+  "TINYINT",
+  // 1-byte A very small integer. Numeric value with scale 0. Signed: -126 to +127. Unsigned: 0 to 253.
+  "SMALLINT",
+  // 2-bytes A small integer. Signed: -32,766 to 32,767. Unsigned: 0 to 65,533.
+  "MEDIUMINT",
+  // 3-bytes A medium integer. Signed: -8388608 to 8388607. Unsigned: 0 to 16777215. Supported starting with MariaDB ColumnStore 1.4.2.
+  "INTEGER",
+  // 4-bytes A normal-size integer. Numeric value with scale 0. Signed: -2,147,483,646 to 2,147,483,647. Unsigned: 0 to 4,294,967,293
+  "BIGINT",
+  // 8-bytes A large integer. Numeric value with scale 0. Signed: -9,223,372,036,854,775,806 to +9,223,372,036,854,775,807 Unsigned: 0 to +18,446,744,073,709,551,613
+  "DECIMAL",
+  // 2, 4, or 8 bytes A packed fixed-point number that can have a specific total number of digits and with a set number of digits after a decimal. The maximum precision (total number of digits) that can be specified is 18.
+  "FLOAT",
+  // 4 bytes Stored in 32-bit IEEE-754 floating point format. As such, the number of significant digits is about 6, and the range of values is approximately +/- 1e38.
+  "DOUBLE"
+  // 8 bytes Stored in 64-bit IEEE-754 floating point format. As such, the number of significant digits is about 15 and the range of values is approximately +/-1e308.
+]);
+var mariaDbColumnStringTypesSchema = import_zod3.z.enum([
+  "CHAR",
+  // 1, 2, 4, or 8 bytes Holds letters and special characters of fixed length. Max length is 255. Default and minimum size is 1 byte.
+  "VARCHAR",
+  // 1, 2, 4, or 8 bytes or 8-byte token Holds letters, numbers, and special characters of variable length. Max length = 8000 bytes or characters and minimum length = 1 byte or character.
+  "TINYTEXT",
+  // 255 bytes Holds a small amount of letters, numbers, and special characters of variable length. Supported from version 1.1.0 onwards.
+  "TINYBLOB",
+  // 255 bytes Holds a small amount of binary data of variable length. Supported from version 1.1.0 onwards.
+  "TEXT",
+  // 64 KB Holds letters, numbers, and special characters of variable length. Supported from version 1.1.0 onwards.
+  "BLOB",
+  // 64 KB Holds binary data of variable length. Supported from version 1.1.0 onwards.
+  "MEDIUMTEXT",
+  // 16 MB Holds a medium amount of letters, numbers, and special characters of variable length. Supported from version 1.1.0 onwards.
+  "MEDIUMBLOB",
+  // 16 MB Holds a medium amount of binary data of variable length. Supported from version 1.1.0 onwards.
+  "LONGTEXT",
+  // 1.96 GB Holds a large amount of letters, numbers, and special characters of variable length. Supported from version 1.1.0 onwards.
+  "JSON",
+  // Alias for LONGTEXT, creates a CONSTRAINT for JSON_VALID, holds a JSON-formatted string of plain text.
+  "LONGBLOB",
+  // 1.96 GB Holds a large amount of binary data of variable length. Supported from version 1.1.0 onwards.
+  "ENUM"
+  // Enum type
+]);
+var mariaDbColumnDateTypesSchema = import_zod3.z.enum([
+  "DATE",
+  // 4-bytes Date has year, month, and day.
+  "DATETIME",
+  // 8-bytes A date and time combination. Supported range is 1000-01-01 00:00:00 to 9999-12-31 23:59:59. From version 1.2.0 microseconds are also supported.
+  "TIME",
+  // 8-bytes Holds hour, minute, second and optionally microseconds for time.
+  "TIMESTAMP"
+  // 4-bytes Values are stored as the number of seconds since 1970-01-01 00:00:00 UTC, and optionally microseconds.
+]);
+var columnDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  type: import_zod3.z.union([
+    postgresColumnNumericTypesSchema,
+    postgresColumnStringTypesSchema,
+    postgresColumnDateTypesSchema,
+    postgresColumnJsonTypesSchema,
+    mariaDbColumnNumericTypesSchema,
+    mariaDbColumnStringTypesSchema,
+    mariaDbColumnDateTypesSchema
+  ]),
+  isNullable: import_zod3.z.boolean(),
+  roles: import_zod3.z.array(import_zod3.z.string()),
+  comment: import_zod3.z.string().optional(),
+  default: import_zod3.z.string().optional(),
+  value: import_zod3.z.string().optional(),
+  isPrimary: import_zod3.z.boolean().optional(),
+  isUnique: import_zod3.z.boolean().optional(),
+  hasAutoIncrement: import_zod3.z.boolean().optional(),
+  length: import_zod3.z.number().optional()
+}).strict();
+var indexDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  columns: import_zod3.z.array(import_zod3.z.string()),
+  isUnique: import_zod3.z.boolean(),
+  isPrimaryKey: import_zod3.z.boolean(),
+  order: import_zod3.z.enum(["ASC", "DESC"])
+}).strict();
+var foreignKeyActionsSchema = import_zod3.z.enum([
+  "CASCADE",
+  // CASCADE action for foreign keys
+  "SET NULL",
+  // SET NULL action for foreign keys
+  "RESTRICT",
+  // RESTRICT action for foreign keys
+  "NO ACTION",
+  // NO ACTION for foreign keys
+  "SET DEFAULT"
+  // SET DEFAULT action for foreign keys
+]);
+var foreignKeyDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  column: import_zod3.z.string(),
+  refTable: import_zod3.z.string(),
+  refColumn: import_zod3.z.string(),
+  onDelete: foreignKeyActionsSchema,
+  onUpdate: foreignKeyActionsSchema
+}).strict();
+var checkConstraintDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  check: import_zod3.z.string()
+}).strict();
+var tableDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  columns: import_zod3.z.array(columnDataSchema),
+  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())
+}).strict();
+var endpointDataSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  baseUrl: import_zod3.z.string(),
+  routes: import_zod3.z.array(import_zod3.z.union([standardRouteSchema, customRouteSchema]))
+}).strict();
+var resturaZodSchema = 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()
+}).strict();
+async function isSchemaValid(schemaToCheck) {
+  try {
+    resturaZodSchema.parse(schemaToCheck);
+    return true;
+  } catch (error) {
+    logger.error(error);
+    return false;
+  }
+}
+
+// src/restura/validateRequestParams.ts
+var import_core_utils2 = require("@redskytech/core-utils");
+var import_jsonschema = __toESM(require("jsonschema"));
+var import_zod4 = require("zod");
+
+// src/restura/utils/addQuotesToStrings.ts
+function addQuotesToStrings(variable) {
+  if (typeof variable === "string") {
+    return `'${variable}'`;
+  } else if (Array.isArray(variable)) {
+    const arrayWithQuotes = variable.map(addQuotesToStrings);
+    return arrayWithQuotes;
+  } else {
+    return variable;
+  }
+}
+
+// src/restura/validateRequestParams.ts
+function validateRequestParams(req, routeData, validationSchema) {
+  const requestData = getRequestData(req);
+  req.data = requestData;
+  if (routeData.request === void 0) {
+    if (routeData.type !== "CUSTOM_ONE" && routeData.type !== "CUSTOM_ARRAY" && routeData.type !== "CUSTOM_PAGED")
+      throw new RsError("BAD_REQUEST", `No request parameters provided for standard request.`);
+    if (!routeData.responseType) throw new RsError("BAD_REQUEST", `No response type defined for custom request.`);
+    if (!routeData.requestType) throw new RsError("BAD_REQUEST", `No request type defined for custom request.`);
+    const currentInterface = validationSchema[routeData.requestType];
+    const validator = new import_jsonschema.default.Validator();
+    const executeValidation = validator.validate(req.data, currentInterface);
+    if (!executeValidation.valid) {
+      throw new RsError(
+        "BAD_REQUEST",
+        `Request custom setup has failed the following check: (${executeValidation.errors})`
+      );
+    }
+    return;
+  }
+  Object.keys(req.data).forEach((requestParamName) => {
+    const requestParam = routeData.request.find((param) => param.name === requestParamName);
+    if (!requestParam) {
+      throw new RsError("BAD_REQUEST", `Request param (${requestParamName}) is not allowed`);
+    }
+  });
+  routeData.request.forEach((requestParam) => {
+    const requestValue = requestData[requestParam.name];
+    if (requestParam.required && requestValue === void 0)
+      throw new RsError("BAD_REQUEST", `Request param (${requestParam.name}) is required but missing`);
+    else if (!requestParam.required && requestValue === void 0) return;
+    validateRequestSingleParam(requestValue, requestParam);
+  });
+}
+function validateRequestSingleParam(requestValue, requestParam) {
+  if (requestParam.isNullable && requestValue === null) return;
+  requestParam.validator.forEach((validator) => {
+    switch (validator.type) {
+      case "TYPE_CHECK":
+        performTypeCheck(requestValue, validator, requestParam.name);
+        break;
+      case "MIN":
+        performMinCheck(requestValue, validator, requestParam.name);
+        break;
+      case "MAX":
+        performMaxCheck(requestValue, validator, requestParam.name);
+        break;
+      case "ONE_OF":
+        performOneOfCheck(requestValue, validator, requestParam.name);
+        break;
+    }
+  });
+}
+function isValidType(type, requestValue) {
+  try {
+    expectValidType(type, requestValue);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function expectValidType(type, requestValue) {
+  if (type === "number") {
+    return import_zod4.z.number().parse(requestValue);
+  }
+  if (type === "string") {
+    return import_zod4.z.string().parse(requestValue);
+  }
+  if (type === "boolean") {
+    return import_zod4.z.boolean().parse(requestValue);
+  }
+  if (type === "string[]") {
+    return import_zod4.z.array(import_zod4.z.string()).parse(requestValue);
+  }
+  if (type === "number[]") {
+    return import_zod4.z.array(import_zod4.z.number()).parse(requestValue);
+  }
+  if (type === "any[]") {
+    return import_zod4.z.array(import_zod4.z.any()).parse(requestValue);
+  }
+  if (type === "object") {
+    return import_zod4.z.object({}).strict().parse(requestValue);
+  }
+}
+function performTypeCheck(requestValue, validator, requestParamName) {
+  if (!isValidType(validator.value, requestValue)) {
+    throw new RsError(
+      "BAD_REQUEST",
+      `Request param (${requestParamName}) with value (${addQuotesToStrings(requestValue)}) is not of type (${validator.value})`
+    );
+  }
+  try {
+    validatorDataSchemeValue.parse(validator.value);
+  } catch (e) {
+    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value}) is not a valid type`);
+  }
+}
+function expectOnlyNumbers(requestValue, validator, requestParamName) {
+  if (!isValueNumber(requestValue))
+    throw new RsError(
+      "BAD_REQUEST",
+      `Request param (${requestParamName}) with value (${requestValue}) is not of type number`
+    );
+  if (!isValueNumber(validator.value))
+    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value} is not of type number`);
+}
+function performMinCheck(requestValue, validator, requestParamName) {
+  expectOnlyNumbers(requestValue, validator, requestParamName);
+  if (requestValue < validator.value)
+    throw new RsError(
+      "BAD_REQUEST",
+      `Request param (${requestParamName}) with value (${requestValue}) is less than (${validator.value})`
+    );
+}
+function performMaxCheck(requestValue, validator, requestParamName) {
+  expectOnlyNumbers(requestValue, validator, requestParamName);
+  if (requestValue > validator.value)
+    throw new RsError(
+      "BAD_REQUEST",
+      `Request param (${requestParamName}) with value (${requestValue}) is more than (${validator.value})`
+    );
+}
+function performOneOfCheck(requestValue, validator, requestParamName) {
+  if (!import_core_utils2.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`);
+  if (!validator.value.includes(requestValue))
+    throw new RsError(
+      "BAD_REQUEST",
+      `Request param (${requestParamName}) with value (${requestValue}) is not one of (${validator.value.join(", ")})`
+    );
+}
+function isValueNumber(value) {
+  return !isNaN(Number(value));
+}
+function getRequestData(req) {
+  let body = "";
+  if (req.method === "GET" || req.method === "DELETE") {
+    body = "query";
+  } else {
+    body = "body";
+  }
+  const bodyData = req[body];
+  if (bodyData && body === "query") {
+    for (const attr in bodyData) {
+      if (bodyData[attr] instanceof Array) {
+        const attrList = [];
+        for (const value of bodyData[attr]) {
+          if (isNaN(Number(value))) continue;
+          attrList.push(Number(value));
+        }
+        if (import_core_utils2.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]);
+      }
+    }
+  }
+  return bodyData;
+}
+
+// src/restura/middleware/schemaValidation.ts
+async function schemaValidation(req, res, next) {
+  req.data = getRequestData(req);
+  try {
+    resturaZodSchema.parse(req.data);
+    next();
+  } catch (error) {
+    logger.error(error);
+    res.sendError("BAD_REQUEST", error, 400 /* BAD_REQUEST */);
+  }
+}
+
+// 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/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_pg_format2 = __toESM(require("pg-format"));
+
+// src/restura/sql/PsqlUtils.ts
+var import_pg_format = __toESM(require("pg-format"));
+function escapeColumnName(columnName) {
+  if (columnName === void 0) return "";
+  return `"${columnName.replace(/"/g, "")}"`.replace(".", '"."');
+}
+function questionMarksToOrderedParams(query) {
+  let count = 1;
+  return query.replace(/'\?'|\?/g, () => `$${count++}`);
+}
+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})
+                 VALUES (${values})
+                 RETURNING *`;
+  return query;
+}
+function updateObjectQuery(table, obj, whereStatement) {
+  const setArray = [];
+  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 (typeof value === "boolean") {
+      query += value;
+    } else if (typeof value === "number") {
+      query += value;
+    } else {
+      query += import_pg_format.default.literal(value);
+    }
+    query += strings[index + 1];
+  });
+  return query;
+}
+
+// src/restura/sql/PsqlConnection.ts
+var import_crypto = __toESM(require("crypto"));
+var PsqlConnection = class {
+  constructor() {
+    this.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) {
+      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}`);
+    }
+  }
+  // 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) {
+      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}`);
+    }
+  }
+  logSqlStatement(query, options, queryMetadata, 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);
+      });
+    }
+    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");
+var SqlEngine = class {
+  async runQueryForRoute(req, routeData, schema) {
+    if (!this.doesRoleHavePermissionToTable(req.requesterDetails.role, schema, routeData.table))
+      throw new RsError("UNAUTHORIZED", "You do not have permission to access this table");
+    switch (routeData.method) {
+      case "POST":
+        return this.executeCreateRequest(req, routeData, schema);
+      case "GET":
+        return this.executeGetRequest(req, routeData, schema);
+      case "PUT":
+      case "PATCH":
+        return this.executeUpdateRequest(req, routeData, schema);
+      case "DELETE":
+        return this.executeDeleteRequest(req, routeData, schema);
+    }
+  }
+  getTableSchema(schema, tableName) {
+    const tableSchema = schema.database.find((item) => item.name === tableName);
+    if (!tableSchema) throw new RsError("SCHEMA_ERROR", `Table ${tableName} not found in schema`);
+    return tableSchema;
+  }
+  doesRoleHavePermissionToColumn(role, schema, item, joins) {
+    if (item.selector) {
+      let tableName = item.selector.split(".")[0];
+      const columnName = item.selector.split(".")[1];
+      let tableSchema = schema.database.find((item2) => item2.name === tableName);
+      if (!tableSchema) {
+        const join = joins.find((join2) => join2.alias === tableName);
+        if (!join) throw new RsError("SCHEMA_ERROR", `Table ${tableName} not found in schema`);
+        tableName = join.table;
+        tableSchema = schema.database.find((item2) => item2.name === tableName);
+      }
+      if (!tableSchema) throw new RsError("SCHEMA_ERROR", `Table ${tableName} not found in schema`);
+      const columnSchema = tableSchema.columns.find((item2) => item2.name === columnName);
+      if (!columnSchema)
+        throw new RsError("SCHEMA_ERROR", `Column ${columnName} not found in table ${tableName}`);
+      const doesColumnHaveRoles = import_core_utils4.ObjectUtils.isArrayWithData(columnSchema.roles);
+      if (!doesColumnHaveRoles) return true;
+      if (!role) return false;
+      return columnSchema.roles.includes(role);
+    }
+    if (item.subquery) {
+      return import_core_utils4.ObjectUtils.isArrayWithData(
+        item.subquery.properties.filter((nestedItem) => {
+          return this.doesRoleHavePermissionToColumn(role, schema, nestedItem, joins);
+        })
+      );
+    }
+    return false;
+  }
+  doesRoleHavePermissionToTable(userRole, schema, tableName) {
+    const tableSchema = this.getTableSchema(schema, tableName);
+    const doesTableHaveRoles = import_core_utils4.ObjectUtils.isArrayWithData(tableSchema.roles);
+    if (!doesTableHaveRoles) return true;
+    if (!userRole) return false;
+    return tableSchema.roles.includes(userRole);
+  }
+  replaceParamKeywords(value, routeData, req, sqlParams) {
+    let returnValue = value;
+    returnValue = this.replaceLocalParamKeywords(returnValue, routeData, req, sqlParams);
+    returnValue = this.replaceGlobalParamKeywords(returnValue, routeData, req, sqlParams);
+    return returnValue;
+  }
+  replaceLocalParamKeywords(value, routeData, req, sqlParams) {
+    var _a2;
+    if (!routeData.request) return value;
+    const data = req.data;
+    if (typeof value === "string") {
+      (_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("$", "");
+        });
+        if (!requestParam)
+          throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
+        sqlParams.push(data[requestParam.name]);
+      });
+      return value.replace(new RegExp(/\$[a-zA-Z][a-zA-Z0-9_]+/g), "?");
+    }
+    return value;
+  }
+  replaceGlobalParamKeywords(value, routeData, req, sqlParams) {
+    var _a2;
+    if (typeof value === "string") {
+      (_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)
+          throw new RsError(
+            "SCHEMA_ERROR",
+            `Invalid global keyword clause in route (${routeData.path}) when looking for (#${param})`
+          );
+        sqlParams.push(globalParamValue);
+      });
+      return value.replace(new RegExp(/#[a-zA-Z][a-zA-Z0-9_]+/g), "?");
+    }
+    return value;
+  }
+};
+
+// 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 
+    { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
+    / expression
+
+expression = 
+    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? " NOT " : ""}(\${expression})\`; }
+
+negate = "!"
+    
+operator = "and"i / "or"i
+
+	   
+column = left:text "." right:text { return  \`\${quoteSqlIdentity(left)}.\${quoteSqlIdentity(right)}\`; } 
+    / 
+    text:text { return quoteSqlIdentity(text); } 
+    
+
+text = text:[a-z0-9 \\t\\r\\n\\-_:@]i+ { return text.join(""); }
+
+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)}%'\`; } } /
+    text:"exact" { return function(column, value)    { return \`\${column} = '\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= '\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"greaterThan" { return function(column, value) { return \`\${column} > '\${format.literal(value).slice(1,-1)}'\`; } } /
+    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; }
+
+
+`;
+var filterPsqlParser = import_pegjs.default.generate(filterSqlGrammar, {
+  format: "commonjs",
+  dependencies: { format: "pg-format" }
+});
+var filterPsqlParser_default = filterPsqlParser;
+
+// src/restura/eventManager.ts
+var import_bluebird2 = __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_bluebird2.default.map(
+      this.actionHandlers.DATABASE_ROW_INSERT,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
+        const insertData = {
+          tableName: triggerResult.table,
+          insertId: triggerResult.record.id,
+          insertObject: triggerResult.record,
+          queryMetadata: data.queryMetadata
+        };
+        callback(insertData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireDeleteActions(data, triggerResult) {
+    await import_bluebird2.default.map(
+      this.actionHandlers.DATABASE_ROW_DELETE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
+        const deleteData = {
+          tableName: triggerResult.table,
+          deletedRow: triggerResult.previousRecord,
+          queryMetadata: data.queryMetadata
+        };
+        callback(deleteData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireUpdateActions(data, triggerResult) {
+    await import_bluebird2.default.map(
+      this.actionHandlers.DATABASE_COLUMN_UPDATE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
+        const columnChangeData = {
+          tableName: triggerResult.table,
+          rowId: triggerResult.record.id,
+          newData: triggerResult.record,
+          oldData: triggerResult.previousRecord,
+          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 !== filter.tableName) return false;
+          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/sql/PsqlEngine.ts
+var { Client } = import_pg2.default;
+var systemUser = {
+  role: "",
+  host: "",
+  ipAddress: "",
+  isSystemUser: true
+};
+var PsqlEngine = class extends SqlEngine {
+  constructor(psqlConnectionPool, shouldListenForDbTriggers = false) {
+    super();
+    this.psqlConnectionPool = psqlConnectionPool;
+    if (shouldListenForDbTriggers) {
+      this.setupTriggerListeners = this.listenForDbTriggers();
+    }
+  }
+  async close() {
+    if (this.triggerClient) {
+      await this.triggerClient.end();
+    }
+  }
+  async listenForDbTriggers() {
+    this.triggerClient = new Client({
+      user: this.psqlConnectionPool.poolConfig.user,
+      host: this.psqlConnectionPool.poolConfig.host,
+      database: this.psqlConnectionPool.poolConfig.database,
+      password: this.psqlConnectionPool.poolConfig.password,
+      port: this.psqlConnectionPool.poolConfig.port,
+      connectionTimeoutMillis: 2e3
+    });
+    await this.triggerClient.connect();
+    const promises = [];
+    promises.push(this.triggerClient.query("LISTEN insert"));
+    promises.push(this.triggerClient.query("LISTEN update"));
+    promises.push(this.triggerClient.query("LISTEN delete"));
+    await Promise.all(promises);
+    this.triggerClient.on("notification", async (msg) => {
+      if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
+        const payload = import_core_utils5.ObjectUtils.safeParse(msg.payload);
+        await this.handleTrigger(payload, msg.channel.toUpperCase());
+      }
+    });
+  }
+  async handleTrigger(payload, mutationType) {
+    const findRequesterDetailsRegex = /^--QUERY_METADATA\(\{.*\}\)/;
+    const match = payload.query.match(findRequesterDetailsRegex);
+    if (match) {
+      const jsonString = match[0].slice(match[0].indexOf("{"), match[0].lastIndexOf("}") + 1);
+      const queryMetadata = import_core_utils5.ObjectUtils.safeParse(jsonString);
+      const triggerFromThisInstance = queryMetadata.connectionInstanceId === this.psqlConnectionPool.instanceId;
+      if (!triggerFromThisInstance) {
+        return;
+      }
+      await eventManager_default.fireActionFromDbTrigger({ queryMetadata, mutationType }, payload);
+    }
+  }
+  async createDatabaseFromSchema(schema, connection) {
+    const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
+    await connection.runQuery(sqlFullStatement, [], systemUser);
+    return sqlFullStatement;
+  }
+  generateDatabaseSchemaFromSchema(schema) {
+    const sqlStatements = [];
+    const indexes = [];
+    const triggers = [];
+    for (const table of schema.database) {
+      triggers.push(this.createInsertTriggers(table.name));
+      triggers.push(this.createUpdateTrigger(table.name));
+      triggers.push(this.createDeleteTrigger(table.name));
+      let sql = `CREATE TABLE "${table.name}"
+					   ( `;
+      const tableColumns = [];
+      for (const column of table.columns) {
+        let columnSql = "";
+        columnSql += `	"${column.name}" ${schemaToPsqlType(column)}`;
+        let value = column.value;
+        if (column.type === "JSON") value = "";
+        if (column.type === "JSONB") value = "";
+        if (column.type === "DECIMAL" && value) {
+          value = value.replace("-", ",").replace(/['"]/g, "");
+        }
+        if (value && column.type !== "ENUM") {
+          columnSql += `(${value})`;
+        } else if (column.length) columnSql += `(${column.length})`;
+        if (column.isPrimary) {
+          columnSql += " PRIMARY KEY ";
+        }
+        if (column.isUnique) {
+          columnSql += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE `;
+        }
+        if (column.isNullable) columnSql += " NULL";
+        else columnSql += " NOT NULL";
+        if (column.default) columnSql += ` DEFAULT ${column.default}`;
+        if (value && column.type === "ENUM") {
+          columnSql += ` CHECK ("${column.name}" IN (${value}))`;
+        }
+        tableColumns.push(columnSql);
+      }
+      sql += tableColumns.join(", \n");
+      for (const index of table.indexes) {
+        if (!index.isPrimaryKey) {
+          let unique = " ";
+          if (index.isUnique) unique = "UNIQUE ";
+          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 "";
+    if (!import_core_utils5.ObjectUtils.isArrayWithData(
+      item.subquery.properties.filter((nestedItem) => {
+        return this.doesRoleHavePermissionToColumn(req.requesterDetails.role, schema, nestedItem, [
+          ...routeData.joins,
+          ...item.subquery.joins
+        ]);
+      })
+    )) {
+      return "'[]'";
+    }
+    return `COALESCE((SELECT JSON_AGG(JSON_BUILD_OBJECT(
+			${item.subquery.properties.map((nestedItem) => {
+      if (!this.doesRoleHavePermissionToColumn(req.requesterDetails.role, schema, nestedItem, [
+        ...routeData.joins,
+        ...item.subquery.joins
+      ])) {
+        return;
+      }
+      if (nestedItem.subquery) {
+        return `'${nestedItem.name}', ${this.createNestedSelect(
+          // recursion
+          req,
+          schema,
+          nestedItem,
+          routeData,
+          userRole,
+          sqlParams
+        )}`;
+      }
+      return `'${nestedItem.name}', ${escapeColumnName(nestedItem.selector)}`;
+    }).filter(Boolean).join(", ")}
+						)) 
+						FROM
+							"${item.subquery.table}"
+							${this.generateJoinStatements(req, item.subquery.joins, item.subquery.table, routeData, schema, userRole, sqlParams)}
+							${this.generateWhereClause(req, item.subquery.where, routeData, sqlParams)}
+					), '[]')`;
+  }
+  async executeCreateRequest(req, routeData, schema) {
+    const sqlParams = [];
+    const parameterObj = {};
+    (routeData.assignments || []).forEach((assignment) => {
+      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.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);
+  }
+  async executeGetRequest(req, routeData, schema) {
+    const DEFAULT_PAGED_PAGE_NUMBER = 0;
+    const DEFAULT_PAGED_PER_PAGE_NUMBER = 25;
+    const sqlParams = [];
+    const userRole = req.requesterDetails.role;
+    let sqlStatement = "";
+    const selectColumns = [];
+    routeData.response.forEach((item) => {
+      if (item.subquery || this.doesRoleHavePermissionToColumn(userRole, schema, item, routeData.joins))
+        selectColumns.push(item);
+    });
+    if (!selectColumns.length) throw new RsError("UNAUTHORIZED", `You do not have permission to access this data.`);
+    let selectStatement = "SELECT \n";
+    selectStatement += `	${selectColumns.map((item) => {
+      if (item.subquery) {
+        return `${this.createNestedSelect(req, schema, item, routeData, userRole, sqlParams)} AS ${escapeColumnName(
+          item.name
+        )}`;
+      }
+      return `${escapeColumnName(item.selector)} AS ${escapeColumnName(item.name)}`;
+    }).join(",\n	")}
+`;
+    sqlStatement += `FROM "${routeData.table}"
+`;
+    sqlStatement += this.generateJoinStatements(
+      req,
+      routeData.joins,
+      routeData.table,
+      routeData,
+      schema,
+      userRole,
+      sqlParams
+    );
+    sqlStatement += this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    let groupByOrderByStatement = this.generateGroupBy(routeData);
+    groupByOrderByStatement += this.generateOrderBy(req, routeData);
+    if (routeData.type === "ONE") {
+      return this.psqlConnectionPool.queryOne(
+        `${selectStatement}${sqlStatement}${groupByOrderByStatement};`,
+        sqlParams,
+        req.requesterDetails
+      );
+    } else if (routeData.type === "ARRAY") {
+      return this.psqlConnectionPool.runQuery(
+        `${selectStatement}${sqlStatement}${groupByOrderByStatement};`,
+        sqlParams,
+        req.requesterDetails
+      );
+    } else if (routeData.type === "PAGED") {
+      const data = req.data;
+      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(totalResponse)) {
+        total = totalResponse[0].total;
+      }
+      return { data: pageResults, total };
+    } else {
+      throw new RsError("UNKNOWN_ERROR", "Unknown route type.");
+    }
+  }
+  async executeUpdateRequest(req, routeData, schema) {
+    const sqlParams = [];
+    const _a2 = req.body, { id } = _a2, bodyNoId = __objRest(_a2, ["id"]);
+    const table = schema.database.find((item) => {
+      return item.name === routeData.table;
+    });
+    if (!table) throw new RsError("UNKNOWN_ERROR", "Unknown table.");
+    if (table.columns.find((column) => column.name === "modifiedOn")) {
+      bodyNoId.modifiedOn = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    for (const assignment of routeData.assignments) {
+      const column = table.columns.find((column2) => column2.name === assignment.name);
+      if (!column) continue;
+      const assignmentWithPrefix = escapeColumnName(`${routeData.table}.${assignment.name}`);
+      if (SqlUtils.convertDatabaseTypeToTypescript(column.type) === "number")
+        bodyNoId[assignmentWithPrefix] = Number(assignment.value);
+      else bodyNoId[assignmentWithPrefix] = assignment.value;
+    }
+    const whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    const query = updateObjectQuery(routeData.table, bodyNoId, whereClause);
+    await this.psqlConnectionPool.queryOne(query, [...sqlParams], req.requesterDetails);
+    return this.executeGetRequest(req, routeData, schema);
+  }
+  async executeDeleteRequest(req, routeData, schema) {
+    const sqlParams = [];
+    const joinStatement = this.generateJoinStatements(
+      req,
+      routeData.joins,
+      routeData.table,
+      routeData,
+      schema,
+      req.requesterDetails.role,
+      sqlParams
+    );
+    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;
+  }
+  generateJoinStatements(req, joins, baseTable, routeData, schema, userRole, sqlParams) {
+    let joinStatements = "";
+    joins.forEach((item) => {
+      if (!this.doesRoleHavePermissionToTable(userRole, schema, item.table))
+        throw new RsError("UNAUTHORIZED", "You do not have permission to access this table");
+      if (item.custom) {
+        const customReplaced = this.replaceParamKeywords(item.custom, routeData, req, sqlParams);
+        joinStatements += `	${item.type} JOIN ${escapeColumnName(item.table)} ON ${customReplaced}
+`;
+      } else {
+        joinStatements += `	${item.type} JOIN ${escapeColumnName(item.table)}${item.alias ? `AS "${item.alias}"` : ""} ON "${baseTable}"."${item.localColumnName}" = ${escapeColumnName(item.alias ? item.alias : item.table)}.${escapeColumnName(
+          item.foreignColumnName
+        )}
+`;
+      }
+    });
+    return joinStatements;
+  }
+  generateGroupBy(routeData) {
+    let groupBy = "";
+    if (routeData.groupBy) {
+      groupBy = `GROUP BY ${escapeColumnName(routeData.groupBy.tableName)}.${escapeColumnName(routeData.groupBy.columnName)}
+`;
+    }
+    return groupBy;
+  }
+  generateOrderBy(req, routeData) {
+    let orderBy = "";
+    const orderOptions = {
+      ASC: "ASC",
+      DESC: "DESC"
+    };
+    const data = req.data;
+    if (routeData.type === "PAGED" && "sortBy" in data) {
+      const sortOrder = orderOptions[data.sortOrder] || "ASC";
+      orderBy = `ORDER BY ${escapeColumnName(data.sortBy)} ${sortOrder}
+`;
+    } else if (routeData.orderBy) {
+      const sortOrder = orderOptions[routeData.orderBy.order] || "ASC";
+      orderBy = `ORDER BY ${escapeColumnName(routeData.orderBy.tableName)}.${escapeColumnName(routeData.orderBy.columnName)} ${sortOrder}
+`;
+    }
+    return orderBy;
+  }
+  generateWhereClause(req, where, routeData, sqlParams) {
+    let whereClause = "";
+    where.forEach((item, index) => {
+      if (index === 0) whereClause = "WHERE ";
+      if (item.custom) {
+        whereClause += this.replaceParamKeywords(item.custom, routeData, req, sqlParams);
+        return;
+      }
+      if (item.operator === void 0 || item.value === void 0 || item.columnName === void 0 || item.tableName === void 0)
+        throw new RsError(
+          "SCHEMA_ERROR",
+          `Invalid where clause in route ${routeData.name}, missing required fields if not custom`
+        );
+      let operator = item.operator;
+      if (operator === "LIKE") {
+        item.value = `'%${item.value}%'`;
+      } else if (operator === "STARTS WITH") {
+        operator = "LIKE";
+        item.value = `'${item.value}%'`;
+      } else if (operator === "ENDS WITH") {
+        operator = "LIKE";
+        item.value = `'%${item.value}'`;
+      }
+      const replacedValue = this.replaceParamKeywords(item.value, routeData, req, sqlParams);
+      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 _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 ((_a2 = data[requestParam.name]) == null ? void 0 : _a2.toString()) || "";
+      });
+      statement = statement.replace(/#[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
+        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 ((_a2 = data[requestParam.name]) == null ? void 0 : _a2.toString()) || "";
+      });
+      statement = filterPsqlParser_default.parse(statement);
+      if (whereClause.startsWith("WHERE")) {
+        whereClause += ` AND (${statement})
+`;
+      } else {
+        whereClause += `WHERE ${statement}
+`;
+      }
+    }
+    return whereClause;
+  }
+  createUpdateTrigger(tableName) {
+    return ` 
+CREATE OR REPLACE FUNCTION notify_${tableName}_update()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('update', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+    AFTER UPDATE ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+		`;
+  }
+  createDeleteTrigger(tableName) {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('delete', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_delete"
+    AFTER DELETE ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_delete();
+		`;
+  }
+  createInsertTriggers(tableName) {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('insert', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER "${tableName}_insert"
+    AFTER INSERT ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+		`;
+  }
+};
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "handleTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createUpdateTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createDeleteTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createInsertTriggers", 1);
+function schemaToPsqlType(column) {
+  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/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 customTypes = newSchema.customTypes !== latestSchema.customTypes;
+    const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
+    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);
+      }
+    });
+    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"
+      });
+    });
+    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/middleware/getMulterUploadSingleton.ts
+var import_multer = __toESM(require("multer"));
+var import_path3 = require("path");
+var os = __toESM(require("os"));
+var OneHundredMB = 100 * 1024 * 1024;
+var commonUpload = null;
+var getMulterUploadSingleton = (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/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_bluebird3 = __toESM(require("bluebird"));
+var os2 = __toESM(require("os"));
+var import_internal3 = require("@restura/internal");
+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_pg3.default;
+var ResturaEngine = class {
+  constructor() {
+    this.publicEndpoints = {
+      GET: [],
+      POST: [],
+      PUT: [],
+      PATCH: [],
+      DELETE: []
+    };
+  }
+  /**
+   * Initializes the Restura engine with the provided Express application.
+   *
+   * @param app - The Express application instance to initialize with Restura.
+   * @returns A promise that resolves when the initialization is complete.
+   */
+  async init(app, authenticationHandler, psqlConnectionPool) {
+    this.resturaConfig = import_internal4.config.validate("restura", resturaConfigSchema);
+    this.multerCommonUpload = getMulterUploadSingleton(this.resturaConfig.fileTempCachePath);
+    new TempCache(this.resturaConfig.fileTempCachePath);
+    this.psqlConnectionPool = psqlConnectionPool;
+    this.psqlEngine = new PsqlEngine(this.psqlConnectionPool, true);
+    setupPgReturnTypes();
+    await customApiFactory_default.loadApiFiles(this.resturaConfig.customApiFolderPath);
+    this.authenticationHandler = authenticationHandler;
+    app.use((0, import_compression.default)());
+    app.use(import_body_parser.default.json({ limit: "32mb" }));
+    app.use(import_body_parser.default.urlencoded({ limit: "32mb", extended: false }));
+    app.use((0, import_cookie_parser.default)());
+    app.disable("x-powered-by");
+    app.use("/", addApiResponseFunctions);
+    app.use("/api/", authenticateUser(this.authenticationHandler));
+    app.use("/restura", this.resturaAuthentication);
+    app.put(
+      "/restura/v1/schema",
+      schemaValidation,
+      this.updateSchema
+    );
+    app.post(
+      "/restura/v1/schema/preview",
+      schemaValidation,
+      this.previewCreateSchema
+    );
+    app.get("/restura/v1/schema", this.getSchema);
+    app.get("/restura/v1/schema/types", this.getSchemaAndTypes);
+    this.expressApp = app;
+    await this.reloadEndpoints();
+    await this.validateGeneratedTypesFolder();
+    logger.info("Restura Engine Initialized");
+  }
+  /**
+   * Determines if a given endpoint is public based on the HTTP method and full URL. This
+   * is determined on whether the endpoint in the schema has no roles assigned to it.
+   *
+   * @param method - The HTTP method (e.g., 'GET', 'POST', 'PUT', 'PATCH', 'DELETE').
+   * @param fullUrl - The full URL of the endpoint.
+   * @returns A boolean indicating whether the endpoint is public.
+   */
+  isEndpointPublic(method, fullUrl) {
+    if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method)) return false;
+    return this.publicEndpoints[method].includes(fullUrl);
+  }
+  /**
+   * Checks if an endpoint exists for a given HTTP method and full URL.
+   *
+   * @param method - The HTTP method to check (e.g., 'GET', 'POST', 'PUT', 'PATCH', 'DELETE').
+   * @param fullUrl - The full URL of the endpoint to check.
+   * @returns `true` if the endpoint exists, otherwise `false`.
+   */
+  doesEndpointExist(method, fullUrl) {
+    return this.schema.endpoints.some((endpoint) => {
+      if (!fullUrl.startsWith(endpoint.baseUrl)) return false;
+      const pathWithoutBaseUrl = fullUrl.replace(endpoint.baseUrl, "");
+      return endpoint.routes.some((route) => {
+        return route.method === method && route.path === pathWithoutBaseUrl;
+      });
+    });
+  }
+  /**
+   * Generates an API from the provided schema and writes it to the specified output file.
+   *
+   * @param outputFile - The path to the file where the generated API will be written.
+   * @param providedSchema - The schema from which the API will be generated.
+   * @returns A promise that resolves when the API has been successfully generated and written to the output file.
+   */
+  async generateApiFromSchema(outputFile, providedSchema) {
+    import_fs4.default.writeFileSync(
+      outputFile,
+      await apiGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
+    );
+  }
+  /**
+   * Generates a model from the provided schema and writes it to the specified output file.
+   *
+   * @param outputFile - The path to the file where the generated model will be written.
+   * @param providedSchema - The schema from which the model will be generated.
+   * @returns A promise that resolves when the model has been successfully written to the output file.
+   */
+  async generateModelFromSchema(outputFile, providedSchema) {
+    import_fs4.default.writeFileSync(
+      outputFile,
+      await modelGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
+    );
+  }
+  /**
+   * Retrieves the latest file system schema for Restura.
+   *
+   * @returns {Promise<ResturaSchema>} A promise that resolves to the latest Restura schema.
+   * @throws {Error} If the schema file is missing or the schema is not valid.
+   */
+  async getLatestFileSystemSchema() {
+    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_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");
+      throw new Error("Schema is not valid");
+    }
+    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 _a2, _b, _c, _d;
+    const schemaHash = await this.generateHashForSchema(providedSchema);
+    const apiFile = import_fs4.default.readFileSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
+    const apiCreatedSchemaHash = (_b = (_a2 = apiFile.toString().match(/\((.*)\)/)) == null ? void 0 : _a2[1]) != null ? _b : "";
+    const modelFile = import_fs4.default.readFileSync(import_path5.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);
+    this.resturaRouter = express.Router();
+    this.resetPublicEndpoints();
+    let routeCount = 0;
+    for (const endpoint of this.schema.endpoints) {
+      const baseUrl = endpoint.baseUrl.endsWith("/") ? endpoint.baseUrl.slice(0, -1) : endpoint.baseUrl;
+      this.expressApp.use(baseUrl, (req, res, next) => {
+        this.resturaRouter(req, res, next);
+      });
+      for (const route of endpoint.routes) {
+        route.path = route.path.startsWith("/") ? route.path : `/${route.path}`;
+        route.path = route.path.endsWith("/") ? route.path.slice(0, -1) : route.path;
+        const fullUrl = `${baseUrl}${route.path}`;
+        if (route.roles.length === 0) this.publicEndpoints[route.method].push(fullUrl);
+        this.resturaRouter[route.method.toLowerCase()](
+          route.path,
+          // <-- Notice we only use path here since the baseUrl is already added to the router.
+          this.executeRouteLogic
+        );
+        routeCount++;
+      }
+    }
+    this.responseValidator = new ResponseValidator(this.schema);
+    logger.info(`Restura loaded (${routeCount}) endpoint${routeCount > 1 ? "s" : ""}`);
+  }
+  async validateGeneratedTypesFolder() {
+    if (!import_fs4.default.existsSync(this.resturaConfig.generatedTypesPath)) {
+      import_fs4.default.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
+    }
+    const hasApiFile = import_fs4.default.existsSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
+    const hasModelsFile = import_fs4.default.existsSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
+    if (!hasApiFile) {
+      await this.generateApiFromSchema(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+    }
+    if (!hasModelsFile) {
+      await this.generateModelFromSchema(
+        import_path5.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_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+    }
+    if (hashes.schemaHash !== hashes.modelCreatedSchemaHash) {
+      await this.generateModelFromSchema(
+        import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+        this.schema
+      );
+    }
+  }
+  resturaAuthentication(req, res, next) {
+    if (req.headers["x-auth-token"] !== this.resturaConfig.authToken) res.status(401).send("Unauthorized");
+    else next();
+  }
+  async previewCreateSchema(req, res) {
+    try {
+      const schemaDiff = await compareSchema_default.diffSchema(req.data, this.schema, this.psqlEngine);
+      res.send({ data: schemaDiff });
+    } catch (err) {
+      res.status(400).send(err);
+    }
+  }
+  async updateSchema(req, res) {
+    try {
+      this.schema = req.data;
+      await this.storeFileSystemSchema();
+      await this.reloadEndpoints();
+      await this.updateTypes();
+      res.send({ data: "success" });
+    } catch (err) {
+      if (err instanceof Error) res.status(400).send(err.message);
+      else res.status(400).send("Unknown error");
+    }
+  }
+  async updateTypes() {
+    await this.generateApiFromSchema(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+    await this.generateModelFromSchema(
+      import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+      this.schema
+    );
+  }
+  async getSchema(req, res) {
+    res.send({ data: this.schema });
+  }
+  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);
+      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);
+      await this.getMulterFilesIfAny(req, res, routeData);
+      validateRequestParams(req, routeData, this.customTypeValidation);
+      if (this.isCustomRoute(routeData)) {
+        await this.runCustomRouteLogic(req, res, routeData);
+        return;
+      }
+      const data = await this.psqlEngine.runQueryForRoute(
+        req,
+        routeData,
+        this.schema
+      );
+      this.responseValidator.validateResponseParams(data, req.baseUrl, routeData);
+      if (routeData.type === "PAGED") res.sendNoWrap(data);
+      else res.sendData(data);
+    } catch (e) {
+      next(e);
+    }
+  }
+  isCustomRoute(route) {
+    return route.type === "CUSTOM_ONE" || route.type === "CUSTOM_ARRAY" || route.type === "CUSTOM_PAGED";
+  }
+  async runCustomRouteLogic(req, res, routeData) {
+    const version = req.baseUrl.split("/")[2];
+    let domain = routeData.path.split("/")[1];
+    domain = domain.split("-").reduce((acc, value, index) => {
+      if (index === 0) acc = value;
+      else acc += import_core_utils7.StringUtils.capitalizeFirst(value);
+      return acc;
+    }, "");
+    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_utils7.StringUtils.capitalizeFirst(cur);
+    }, "")}`;
+    const customFunction = customApi[functionName];
+    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_crypto2.createHash)("sha256").update(schemaPrettyStr).digest("hex");
+  }
+  async storeFileSystemSchema() {
+    const schemaPrettyStr = await prettier3.format(JSON.stringify(this.schema), __spreadValues({
+      parser: "json"
+    }, {
+      trailingComma: "none",
+      tabWidth: 4,
+      useTabs: true,
+      endOfLine: "lf",
+      printWidth: 120,
+      singleQuote: true
+    }));
+    import_fs4.default.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
+  }
+  resetPublicEndpoints() {
+    this.publicEndpoints = {
+      GET: [],
+      POST: [],
+      PUT: [],
+      PATCH: [],
+      DELETE: []
+    };
+  }
+  validateAuthorization(req, routeData) {
+    const role = req.requesterDetails.role;
+    if (routeData.roles.length === 0 || !role) return;
+    if (!routeData.roles.includes(role))
+      throw new RsError("UNAUTHORIZED", "Not authorized to access this endpoint");
+  }
+  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 === path5;
+    });
+    if (!route) throw new RsError("NOT_FOUND", "Route not found");
+    return route;
+  }
+};
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "resturaAuthentication", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "previewCreateSchema", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "updateSchema", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "getSchema", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "getSchemaAndTypes", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "getMulterFilesIfAny", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "executeRouteLogic", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "isCustomRoute", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "runCustomRouteLogic", 1);
+function 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_pg4 = __toESM(require("pg"));
+var { Client: Client2 } = import_pg4.default;
+var PsqlTransaction = class extends PsqlConnection {
+  constructor(clientConfig) {
+    super();
+    this.clientConfig = clientConfig;
+    this.client = new Client2(clientConfig);
+    this.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 = {
-  isEven
+  HtmlStatusCodes,
+  PsqlConnection,
+  PsqlEngine,
+  PsqlPool,
+  PsqlTransaction,
+  RsError,
+  SQL,
+  escapeColumnName,
+  eventManager,
+  insertObjectQuery,
+  isValueNumber,
+  logger,
+  questionMarksToOrderedParams,
+  restura,
+  updateObjectQuery
 });
 //# sourceMappingURL=index.js.map