@restura/core 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/index.mjs

@@ -47,12 +47,13 @@ import { format } from "logform";
 // src/config.schema.ts
 import { z } from "zod";
 var loggerConfigSchema = z.object({
-  level: z.enum(["info", "warn", "error", "debug"]).default("info")
+  level: z.enum(["info", "warn", "error", "debug", "silly"]).default("info")
 });
 var resturaConfigSchema = z.object({
   authToken: z.string().min(1, "Missing Restura Auth Token"),
   sendErrorStackTrace: z.boolean().default(false),
   schemaFilePath: z.string().default(process.cwd() + "/restura.schema.json"),
+  customApiFolderPath: z.string().default(process.cwd() + "/dist/api"),
   generatedTypesPath: z.string().default(process.cwd() + "/src/@types")
 });
 
@@ -91,8 +92,74 @@ var logger = winston.createLogger({
   ]
 });
 
+// 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
-import { ObjectUtils as ObjectUtils5 } from "@redskytech/core-utils";
+import { ObjectUtils as ObjectUtils5, StringUtils as StringUtils3 } from "@redskytech/core-utils";
 import { config as config2 } from "@restura/internal";
 
 // ../../node_modules/.pnpm/autobind-decorator@2.4.0/node_modules/autobind-decorator/lib/esm/index.js
@@ -147,59 +214,11 @@ import compression from "compression";
 import cookieParser from "cookie-parser";
 import { createHash } from "crypto";
 import * as express from "express";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
+import pg2 from "pg";
 import * as prettier3 from "prettier";
 
-// src/restura/errors.ts
-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];
-  }
-};
-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/sql/SqlUtils.ts
 var SqlUtils = class _SqlUtils {
   static convertDatabaseTypeToTypescript(type, value) {
@@ -291,9 +310,9 @@ var ResponseValidator = class _ResponseValidator {
     return { validator: "any" };
   }
   getTypeFromTable(selector, name) {
-    const path3 = selector.split(".");
-    if (path3.length === 0 || path3.length > 2 || path3[0] === "") return { validator: "any", isOptional: false };
-    const tableName = path3.length == 2 ? path3[0] : name, columnName = path3.length == 2 ? path3[1] : path3[0];
+    const path4 = selector.split(".");
+    if (path4.length === 0 || path4.length > 2 || path4[0] === "") return { validator: "any", isOptional: false };
+    const tableName = path4.length == 2 ? path4[0] : name, columnName = path4.length == 2 ? path4[1] : path4[0];
     const 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 };
@@ -509,10 +528,10 @@ var ApiTree = class _ApiTree {
     return `${p.name}${optional ? "?" : ""}:${responseType}${array ? "[]" : ""}`;
   }
   getTypeFromTable(selector, name) {
-    const path3 = selector.split(".");
-    if (path3.length === 0 || path3.length > 2 || path3[0] === "") return { responseType: "any", optional: false };
-    let tableName = path3.length == 2 ? path3[0] : name;
-    const columnName = path3.length == 2 ? path3[1] : path3[0];
+    const path4 = selector.split(".");
+    if (path4.length === 0 || path4.length > 2 || path4[0] === "") return { responseType: "any", optional: false };
+    let tableName = path4.length == 2 ? path4[0] : name;
+    const columnName = path4.length == 2 ? path4[1] : path4[0];
     let table = this.database.find((t) => t.name == tableName);
     if (!table && tableName.includes("_")) {
       const tableAliasSplit = tableName.split("_");
@@ -527,8 +546,8 @@ var ApiTree = class _ApiTree {
     };
   }
 };
-function pathToNamespaces(path3) {
-  return path3.split("/").map((e) => StringUtils.toPascalCasing(e)).filter((e) => e);
+function pathToNamespaces(path4) {
+  return path4.split("/").map((e) => StringUtils.toPascalCasing(e)).filter((e) => e);
 }
 function apiGenerator(schema, schemaHash) {
   let apiString = `/** Auto generated file from Schema Hash (${schemaHash}). DO NOT MODIFY **/`;
@@ -561,6 +580,92 @@ function apiGenerator(schema, schemaHash) {
   }));
 }
 
+// src/restura/customApiFactory.ts
+import fs from "fs";
+import path from "path";
+var CustomApiFactory = class {
+  constructor() {
+    this.customApis = {};
+  }
+  async loadApiFiles(baseFolderPath) {
+    const apiVersions = ["v1"];
+    for (const apiVersion of apiVersions) {
+      const apiVersionFolderPath = path.join(baseFolderPath, apiVersion);
+      if (!fs.existsSync(apiVersionFolderPath)) continue;
+      await this.addDirectory(apiVersionFolderPath, apiVersion);
+    }
+  }
+  getCustomApi(customApiName) {
+    return this.customApis[customApiName];
+  }
+  async addDirectory(directoryPath, apiVersion) {
+    const entries = fs.readdirSync(directoryPath, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        if (entry.name.endsWith(`.api.${apiVersion}.js`) === false) continue;
+        try {
+          const importPath = `${path.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
+import fs2 from "fs";
+import * as TJS from "typescript-json-schema";
+import path2, { resolve } from "path";
+import tmp from "tmp";
+import * as process2 from "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 = tmp.fileSync({ mode: 420, prefix: "prefix-", postfix: ".ts" });
+  fs2.writeFileSync(temporaryFile.name, currentSchema.customTypes);
+  const compilerOptions = {
+    strictNullChecks: true,
+    skipLibCheck: true
+  };
+  const program = TJS.getProgramFromFiles(
+    [
+      resolve(temporaryFile.name),
+      // find a way to remove
+      path2.join(process2.cwd(), "src/@types/models.d.ts"),
+      path2.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) {
@@ -589,9 +694,17 @@ function addApiResponseFunctions(req, res, next) {
   next();
 }
 
-// src/restura/validateRequestParams.ts
-import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
-import jsonschema from "jsonschema";
+// 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
 import { z as z3 } from "zod";
 
 // src/restura/types/validation.types.ts
@@ -602,264 +715,83 @@ var validatorDataSchema = z2.object({
   value: validatorDataSchemeValue
 }).strict();
 
-// 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 jsonschema.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) {
-  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 z3.number().parse(requestValue);
-  }
-  if (type === "string") {
-    return z3.string().parse(requestValue);
-  }
-  if (type === "boolean") {
-    return z3.boolean().parse(requestValue);
-  }
-  if (type === "string[]") {
-    return z3.array(z3.string()).parse(requestValue);
-  }
-  if (type === "number[]") {
-    return z3.array(z3.number()).parse(requestValue);
-  }
-  if (type === "any[]") {
-    return z3.array(z3.any()).parse(requestValue);
-  }
-  if (type === "object") {
-    return z3.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 (!ObjectUtils2.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) {
-    for (const attr in bodyData) {
-      if (attr === "token") {
-        delete bodyData[attr];
-        continue;
-      }
-      if (bodyData[attr] instanceof Array) {
-        const attrList = [];
-        for (const value of bodyData[attr]) {
-          if (isNaN(Number(value))) continue;
-          attrList.push(Number(value));
-        }
-        if (ObjectUtils2.isArrayWithData(attrList)) {
-          bodyData[attr] = attrList;
-        }
-      } else {
-        bodyData[attr] = ObjectUtils2.safeParse(bodyData[attr]);
-        if (isNaN(Number(bodyData[attr]))) continue;
-        bodyData[attr] = Number(bodyData[attr]);
-      }
-    }
-  }
-  return bodyData;
-}
-
 // src/restura/restura.schema.ts
-import { z as z4 } from "zod";
-var orderBySchema = z4.object({
-  columnName: z4.string(),
-  order: z4.enum(["ASC", "DESC"]),
-  tableName: z4.string()
+var orderBySchema = z3.object({
+  columnName: z3.string(),
+  order: z3.enum(["ASC", "DESC"]),
+  tableName: z3.string()
 }).strict();
-var groupBySchema = z4.object({
-  columnName: z4.string(),
-  tableName: z4.string()
+var groupBySchema = z3.object({
+  columnName: z3.string(),
+  tableName: z3.string()
 }).strict();
-var whereDataSchema = z4.object({
-  tableName: z4.string().optional(),
-  columnName: z4.string().optional(),
-  operator: z4.enum(["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH"]).optional(),
-  value: z4.string().or(z4.number()).optional(),
-  custom: z4.string().optional(),
-  conjunction: z4.enum(["AND", "OR"]).optional()
+var whereDataSchema = z3.object({
+  tableName: z3.string().optional(),
+  columnName: z3.string().optional(),
+  operator: z3.enum(["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH"]).optional(),
+  value: z3.string().or(z3.number()).optional(),
+  custom: z3.string().optional(),
+  conjunction: z3.enum(["AND", "OR"]).optional()
 }).strict();
-var assignmentDataSchema = z4.object({
-  name: z4.string(),
-  value: z4.string()
+var assignmentDataSchema = z3.object({
+  name: z3.string(),
+  value: z3.string()
 }).strict();
-var joinDataSchema = z4.object({
-  table: z4.string(),
-  localColumnName: z4.string().optional(),
-  foreignColumnName: z4.string().optional(),
-  custom: z4.string().optional(),
-  type: z4.enum(["LEFT", "INNER"]),
-  alias: z4.string().optional()
+var joinDataSchema = z3.object({
+  table: z3.string(),
+  localColumnName: z3.string().optional(),
+  foreignColumnName: z3.string().optional(),
+  custom: z3.string().optional(),
+  type: z3.enum(["LEFT", "INNER"]),
+  alias: z3.string().optional()
 }).strict();
-var requestDataSchema = z4.object({
-  name: z4.string(),
-  required: z4.boolean(),
-  validator: z4.array(validatorDataSchema)
+var requestDataSchema = z3.object({
+  name: z3.string(),
+  required: z3.boolean(),
+  validator: z3.array(validatorDataSchema)
 }).strict();
-var responseDataSchema = z4.object({
-  name: z4.string(),
-  selector: z4.string().optional(),
-  subquery: z4.object({
-    table: z4.string(),
-    joins: z4.array(joinDataSchema),
-    where: z4.array(whereDataSchema),
-    properties: z4.array(z4.lazy(() => responseDataSchema)),
+var responseDataSchema = z3.object({
+  name: z3.string(),
+  selector: z3.string().optional(),
+  subquery: z3.object({
+    table: z3.string(),
+    joins: z3.array(joinDataSchema),
+    where: z3.array(whereDataSchema),
+    properties: z3.array(z3.lazy(() => responseDataSchema)),
     // Explicit type for the lazy schema
     groupBy: groupBySchema.optional(),
     orderBy: orderBySchema.optional()
   }).optional()
 }).strict();
-var routeDataBaseSchema = z4.object({
-  method: z4.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
-  name: z4.string(),
-  description: z4.string(),
-  path: z4.string(),
-  roles: z4.array(z4.string())
+var routeDataBaseSchema = z3.object({
+  method: z3.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
+  name: z3.string(),
+  description: z3.string(),
+  path: z3.string(),
+  roles: z3.array(z3.string())
 }).strict();
 var standardRouteSchema = routeDataBaseSchema.extend({
-  type: z4.enum(["ONE", "ARRAY", "PAGED"]),
-  table: z4.string(),
-  joins: z4.array(joinDataSchema),
-  assignments: z4.array(assignmentDataSchema),
-  where: z4.array(whereDataSchema),
-  request: z4.array(requestDataSchema),
-  response: z4.array(responseDataSchema),
+  type: z3.enum(["ONE", "ARRAY", "PAGED"]),
+  table: z3.string(),
+  joins: z3.array(joinDataSchema),
+  assignments: z3.array(assignmentDataSchema),
+  where: z3.array(whereDataSchema),
+  request: z3.array(requestDataSchema),
+  response: z3.array(responseDataSchema),
   groupBy: groupBySchema.optional(),
   orderBy: orderBySchema.optional()
 }).strict();
 var customRouteSchema = routeDataBaseSchema.extend({
-  type: z4.enum(["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]),
-  responseType: z4.union([z4.string(), z4.enum(["string", "number", "boolean"])]),
-  requestType: z4.string().optional(),
-  request: z4.array(requestDataSchema).optional(),
-  table: z4.undefined(),
-  joins: z4.undefined(),
-  assignments: z4.undefined(),
-  fileUploadType: z4.enum(["SINGLE", "MULTIPLE"]).optional()
+  type: z3.enum(["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]),
+  responseType: z3.union([z3.string(), z3.enum(["string", "number", "boolean"])]),
+  requestType: z3.string().optional(),
+  request: z3.array(requestDataSchema).optional(),
+  table: z3.undefined(),
+  joins: z3.undefined(),
+  assignments: z3.undefined(),
+  fileUploadType: z3.enum(["SINGLE", "MULTIPLE"]).optional()
 }).strict();
-var postgresColumnNumericTypesSchema = z4.enum([
+var postgresColumnNumericTypesSchema = z3.enum([
   "SMALLINT",
   // 2 bytes, -32,768 to 32,767
   "INTEGER",
@@ -879,7 +811,7 @@ var postgresColumnNumericTypesSchema = z4.enum([
   "BIGSERIAL"
   // auto-incrementing big integer
 ]);
-var postgresColumnStringTypesSchema = z4.enum([
+var postgresColumnStringTypesSchema = z3.enum([
   "CHAR",
   // fixed-length, blank-padded
   "VARCHAR",
@@ -889,7 +821,7 @@ var postgresColumnStringTypesSchema = z4.enum([
   "BYTEA"
   // binary data
 ]);
-var postgresColumnDateTypesSchema = z4.enum([
+var postgresColumnDateTypesSchema = z3.enum([
   "DATE",
   // calendar date (year, month, day)
   "TIMESTAMP",
@@ -901,7 +833,7 @@ var postgresColumnDateTypesSchema = z4.enum([
   "INTERVAL"
   // time span
 ]);
-var mariaDbColumnNumericTypesSchema = z4.enum([
+var mariaDbColumnNumericTypesSchema = z3.enum([
   "BOOLEAN",
   // 1-byte A synonym for "TINYINT(1)". Supported from version 1.2.0 onwards.
   "TINYINT",
@@ -921,7 +853,7 @@ var mariaDbColumnNumericTypesSchema = z4.enum([
   "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 = z4.enum([
+var mariaDbColumnStringTypesSchema = z3.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",
@@ -947,7 +879,7 @@ var mariaDbColumnStringTypesSchema = z4.enum([
   "ENUM"
   // Enum type
 ]);
-var mariaDbColumnDateTypesSchema = z4.enum([
+var mariaDbColumnDateTypesSchema = z3.enum([
   "DATE",
   // 4-bytes Date has year, month, and day.
   "DATETIME",
@@ -957,9 +889,9 @@ var mariaDbColumnDateTypesSchema = z4.enum([
   "TIMESTAMP"
   // 4-bytes Values are stored as the number of seconds since 1970-01-01 00:00:00 UTC, and optionally microseconds.
 ]);
-var columnDataSchema = z4.object({
-  name: z4.string(),
-  type: z4.union([
+var columnDataSchema = z3.object({
+  name: z3.string(),
+  type: z3.union([
     postgresColumnNumericTypesSchema,
     postgresColumnStringTypesSchema,
     postgresColumnDateTypesSchema,
@@ -967,24 +899,24 @@ var columnDataSchema = z4.object({
     mariaDbColumnStringTypesSchema,
     mariaDbColumnDateTypesSchema
   ]),
-  isNullable: z4.boolean(),
-  roles: z4.array(z4.string()),
-  comment: z4.string().optional(),
-  default: z4.string().optional(),
-  value: z4.string().optional(),
-  isPrimary: z4.boolean().optional(),
-  isUnique: z4.boolean().optional(),
-  hasAutoIncrement: z4.boolean().optional(),
-  length: z4.number().optional()
+  isNullable: z3.boolean(),
+  roles: z3.array(z3.string()),
+  comment: z3.string().optional(),
+  default: z3.string().optional(),
+  value: z3.string().optional(),
+  isPrimary: z3.boolean().optional(),
+  isUnique: z3.boolean().optional(),
+  hasAutoIncrement: z3.boolean().optional(),
+  length: z3.number().optional()
 }).strict();
-var indexDataSchema = z4.object({
-  name: z4.string(),
-  columns: z4.array(z4.string()),
-  isUnique: z4.boolean(),
-  isPrimaryKey: z4.boolean(),
-  order: z4.enum(["ASC", "DESC"])
+var indexDataSchema = z3.object({
+  name: z3.string(),
+  columns: z3.array(z3.string()),
+  isUnique: z3.boolean(),
+  isPrimaryKey: z3.boolean(),
+  order: z3.enum(["ASC", "DESC"])
 }).strict();
-var foreignKeyActionsSchema = z4.enum([
+var foreignKeyActionsSchema = z3.enum([
   "CASCADE",
   // CASCADE action for foreign keys
   "SET NULL",
@@ -996,48 +928,229 @@ var foreignKeyActionsSchema = z4.enum([
   "SET DEFAULT"
   // SET DEFAULT action for foreign keys
 ]);
-var foreignKeyDataSchema = z4.object({
-  name: z4.string(),
-  column: z4.string(),
-  refTable: z4.string(),
-  refColumn: z4.string(),
+var foreignKeyDataSchema = z3.object({
+  name: z3.string(),
+  column: z3.string(),
+  refTable: z3.string(),
+  refColumn: z3.string(),
   onDelete: foreignKeyActionsSchema,
   onUpdate: foreignKeyActionsSchema
 }).strict();
-var checkConstraintDataSchema = z4.object({
-  name: z4.string(),
-  check: z4.string()
+var checkConstraintDataSchema = z3.object({
+  name: z3.string(),
+  check: z3.string()
 }).strict();
-var tableDataSchema = z4.object({
-  name: z4.string(),
-  columns: z4.array(columnDataSchema),
-  indexes: z4.array(indexDataSchema),
-  foreignKeys: z4.array(foreignKeyDataSchema),
-  checkConstraints: z4.array(checkConstraintDataSchema),
-  roles: z4.array(z4.string())
+var tableDataSchema = z3.object({
+  name: z3.string(),
+  columns: z3.array(columnDataSchema),
+  indexes: z3.array(indexDataSchema),
+  foreignKeys: z3.array(foreignKeyDataSchema),
+  checkConstraints: z3.array(checkConstraintDataSchema),
+  roles: z3.array(z3.string())
 }).strict();
-var endpointDataSchema = z4.object({
-  name: z4.string(),
-  description: z4.string(),
-  baseUrl: z4.string(),
-  routes: z4.array(z4.union([standardRouteSchema, customRouteSchema]))
+var endpointDataSchema = z3.object({
+  name: z3.string(),
+  description: z3.string(),
+  baseUrl: z3.string(),
+  routes: z3.array(z3.union([standardRouteSchema, customRouteSchema]))
 }).strict();
-var resturaZodSchema = z4.object({
-  database: z4.array(tableDataSchema),
-  endpoints: z4.array(endpointDataSchema),
-  globalParams: z4.array(z4.string()),
-  roles: z4.array(z4.string()),
-  customTypes: z4.string()
+var resturaZodSchema = z3.object({
+  database: z3.array(tableDataSchema),
+  endpoints: z3.array(endpointDataSchema),
+  globalParams: z3.array(z3.string()),
+  roles: z3.array(z3.string()),
+  customTypes: z3.string()
 }).strict();
 async function isSchemaValid(schemaToCheck) {
   try {
     resturaZodSchema.parse(schemaToCheck);
     return true;
-  } catch (error) {
-    logger.error(error);
+  } catch (error) {
+    logger.error(error);
+    return false;
+  }
+}
+
+// src/restura/validateRequestParams.ts
+import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
+import jsonschema from "jsonschema";
+import { z as z4 } from "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 jsonschema.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) {
+  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 z4.number().parse(requestValue);
+  }
+  if (type === "string") {
+    return z4.string().parse(requestValue);
+  }
+  if (type === "boolean") {
+    return z4.boolean().parse(requestValue);
+  }
+  if (type === "string[]") {
+    return z4.array(z4.string()).parse(requestValue);
+  }
+  if (type === "number[]") {
+    return z4.array(z4.number()).parse(requestValue);
+  }
+  if (type === "any[]") {
+    return z4.array(z4.any()).parse(requestValue);
+  }
+  if (type === "object") {
+    return z4.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 (!ObjectUtils2.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 (ObjectUtils2.isArrayWithData(attrList)) {
+          bodyData[attr] = attrList;
+        }
+      } else {
+        bodyData[attr] = ObjectUtils2.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) {
@@ -1086,55 +1199,52 @@ function convertTable(table) {
   return modelString;
 }
 
-// src/restura/middleware/authenticateUser.ts
-function authenticateUser(applicationAuthenticateHandler) {
-  return (req, res, next) => {
-    applicationAuthenticateHandler(
-      req,
-      (userDetails) => {
-        req.requesterDetails = __spreadValues(__spreadValues({}, req.requesterDetails), userDetails);
-        next();
-      },
-      (errorMessage) => {
-        res.sendError("UNAUTHORIZED", errorMessage);
-      }
-    );
-  };
-}
+// src/restura/sql/PsqlEngine.ts
+import { ObjectUtils as ObjectUtils4 } from "@redskytech/core-utils";
 
-// src/restura/customTypeValidationGenerator.ts
-import fs from "fs";
-import * as TJS from "typescript-json-schema";
-import path, { resolve } from "path";
-import tmp from "tmp";
-import * as process2 from "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 = tmp.fileSync({ mode: 420, prefix: "prefix-", postfix: ".ts" });
-  fs.writeFileSync(temporaryFile.name, currentSchema.customTypes);
-  const compilerOptions = {
-    strictNullChecks: true,
-    skipLibCheck: true
-  };
-  const program = TJS.getProgramFromFiles(
-    [
-      resolve(temporaryFile.name),
-      // find a way to remove
-      path.join(process2.cwd(), "src/@types/models.d.ts"),
-      path.join(process2.cwd(), "src/@types/api.d.ts")
-    ],
-    compilerOptions
-  );
-  customInterfaceNames.forEach((item) => {
-    const ddlSchema = TJS.generateSchema(program, item, {
-      required: true
-    });
-    schemaObject[item] = ddlSchema || {};
+// src/restura/sql/PsqlUtils.ts
+import format2 from "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 (isValueNumber2(value)) {
+      query += value;
+    } else {
+      query += format2.literal(value);
+    }
+    query += strings[index + 1];
   });
-  temporaryFile.removeCallback();
-  return schemaObject;
+  return query;
 }
 
 // src/restura/sql/SqlEngine.ts
@@ -1226,7 +1336,10 @@ var SqlEngine = class {
         param = param.replace("#", "");
         const globalParamValue = req.requesterDetails[param];
         if (!globalParamValue)
-          throw new RsError("SCHEMA_ERROR", `Invalid global keyword clause in route ${routeData.name}`);
+          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), "?");
@@ -1235,7 +1348,7 @@ var SqlEngine = class {
   }
 };
 
-// src/restura/sql/filterSqlParser.ts
+// src/restura/sql/filterPsqlParser.ts
 import peg from "pegjs";
 var filterSqlGrammar = `
 start = expressionList
@@ -1247,7 +1360,7 @@ expressionList =
 
 expression = 
     negate:negate?"(" "column:" column:column ","? value:value? ","? type:type? ")" 
-    {return \`\${negate? "!" : ""}(\${type?  type(column, value) : \`\${column} = \${mysql.escape(value)}\`})\`;}
+    {return \`\${negate? "!" : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
     /
     negate:negate?"("expression:expressionList")" { return \`\${negate? "!" : ""}(\${expression})\`; }
 
@@ -1255,80 +1368,33 @@ negate = "!"
     
 operator = "and"i / "or"i
 
-column = left:text "." right:text { return  \`\${mysql.escapeId(left)}.\${mysql.escapeId(right)}\`; }
-	   /
-	   text:text { return mysql.escapeId(text); }
-
+	   
+column = left:text "." right:text { return  \`\${format.ident(left)}.\${format.ident(right)}\`; } 
+    / 
+    text:text { return format.ident(text); } 
+    
 
-text = text:[ a-z0-9-_:.@]i+ { return text.join("");}
+text = text:[a-z0-9-_:@]i+ { return text.join("");}
 
 type = "type:" type:typeString { return type; }
-typeString = text:"startsWith" { return function(column, value) { return \`\${column} LIKE '\${mysql.escape(value).slice(1,-1)}%'\`; } } /
-    text:"endsWith"  { return function(column, value) { return \`\${column} LIKE '%\${mysql.escape(value).slice(1,-1)}'\`; } } /
-    text:"contains" { return function(column, value) { return \`\${column} LIKE '%\${mysql.escape(value).slice(1,-1)}%'\`; } } /
-    text:"exact" { return function(column, value)    { return \`\${column} = '\${mysql.escape(value).slice(1,-1)}'\`; } } /
-    text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= '\${mysql.escape(value).slice(1,-1)}'\`; } } /
-    text:"greaterThan" { return function(column, value) { return \`\${column} > '\${mysql.escape(value).slice(1,-1)}'\`; } } /
-    text:"lessThanEqual" { return function(column, value) { return \`\${column} <= '\${mysql.escape(value).slice(1,-1)}'\`; } } /
-    text:"lessThan" { return function(column, value) { return \`\${column} < '\${mysql.escape(value).slice(1,-1)}'\`; } } / 
+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 filterSqlParser = peg.generate(filterSqlGrammar, {
-  format: "commonjs"
-  // dependencies: { mysql: 'mysql' } // todo: figure out a better way to escape values depending on the database type
+var filterPsqlParser = peg.generate(filterSqlGrammar, {
+  format: "commonjs",
+  dependencies: { format: "pg-format" }
 });
-var filterSqlParser_default = filterSqlParser;
-
-// src/restura/sql/PsqlEngine.ts
-import { ObjectUtils as ObjectUtils4 } from "@redskytech/core-utils";
-
-// src/restura/sql/PsqlUtils.ts
-import format2 from "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 (isValueNumber2(value)) {
-      query += value;
-    } else {
-      query += format2.literal(value);
-    }
-    query += strings[index + 1];
-  });
-  return query;
-}
+var filterPsqlParser_default = filterPsqlParser;
 
 // src/restura/sql/PsqlEngine.ts
 var PsqlEngine = class extends SqlEngine {
@@ -1345,8 +1411,45 @@ var PsqlEngine = class extends SqlEngine {
     return "";
   }
   createNestedSelect(req, schema, item, routeData, userRole, sqlParams) {
-    console.log(req, schema, item, routeData, userRole, sqlParams);
-    return "";
+    if (!item.subquery) return "";
+    if (!ObjectUtils4.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 = [];
@@ -1355,7 +1458,7 @@ var PsqlEngine = class extends SqlEngine {
       parameterObj[assignment.name] = this.replaceParamKeywords(assignment.value, routeData, req, sqlParams);
     });
     const query = insertObjectQuery(routeData.table, __spreadValues(__spreadValues({}, req.data), parameterObj));
-    const createdItem = await this.psqlConnectionPool.queryOne(query, sqlParams);
+    const createdItem = await this.psqlConnectionPool.queryOne(query, sqlParams, req.requesterDetails);
     const insertId = createdItem == null ? void 0 : createdItem.id;
     const whereData = [
       {
@@ -1405,12 +1508,14 @@ var PsqlEngine = class extends SqlEngine {
     if (routeData.type === "ONE") {
       return this.psqlConnectionPool.queryOne(
         `${selectStatement}${sqlStatement}${groupByOrderByStatement};`,
-        sqlParams
+        sqlParams,
+        req.requesterDetails
       );
     } else if (routeData.type === "ARRAY") {
       return this.psqlConnectionPool.runQuery(
         `${selectStatement}${sqlStatement}${groupByOrderByStatement};`,
-        sqlParams
+        sqlParams,
+        req.requesterDetails
       );
     } else if (routeData.type === "PAGED") {
       const data = req.data;
@@ -1422,7 +1527,8 @@ ${sqlStatement};`,
           data.perPage || DEFAULT_PAGED_PER_PAGE_NUMBER,
           (data.page - 1) * data.perPage || DEFAULT_PAGED_PAGE_NUMBER,
           ...sqlParams
-        ]
+        ],
+        req.requesterDetails
       );
       let total = 0;
       if (ObjectUtils4.isArrayWithData(pageResults)) {
@@ -1453,7 +1559,7 @@ ${sqlStatement};`,
     }
     const whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
     const query = updateObjectQuery(routeData.table, bodyNoId, whereClause);
-    await this.psqlConnectionPool.queryOne(query, [...sqlParams]);
+    await this.psqlConnectionPool.queryOne(query, [...sqlParams], req.requesterDetails);
     return this.executeGetRequest(req, routeData, schema);
   }
   async executeDeleteRequest(req, routeData, schema) {
@@ -1471,16 +1577,26 @@ ${sqlStatement};`,
                            FROM "${routeData.table}" ${joinStatement}`;
     deleteStatement += this.generateWhereClause(req, routeData.where, routeData, sqlParams);
     deleteStatement += ";";
-    await this.psqlConnectionPool.runQuery(deleteStatement, sqlParams);
+    await this.psqlConnectionPool.runQuery(deleteStatement, sqlParams, req.requesterDetails);
     return true;
   }
   generateJoinStatements(req, joins, baseTable, routeData, schema, userRole, sqlParams) {
-    console.log(req, joins, baseTable, routeData, schema, userRole, sqlParams);
-    return "";
-  }
-  getTableSchema(schema, tableName) {
-    console.log(schema, tableName);
-    return {};
+    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 = "";
@@ -1539,22 +1655,24 @@ ${sqlStatement};`,
     const data = req.data;
     if (routeData.type === "PAGED" && !!(data == null ? void 0 : data.filter)) {
       let statement = data.filter.replace(/\$[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
+        var _a;
         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 data[requestParam.name];
+        return ((_a = data[requestParam.name]) == null ? void 0 : _a.toString()) || "";
       });
       statement = statement.replace(/#[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
+        var _a;
         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 data[requestParam.name];
+        return ((_a = data[requestParam.name]) == null ? void 0 : _a.toString()) || "";
       });
-      statement = filterSqlParser_default.parse(statement);
+      statement = filterPsqlParser_default.parse(statement);
       if (whereClause.startsWith("WHERE")) {
         whereClause += ` AND (${statement})
 `;
@@ -1567,24 +1685,33 @@ ${sqlStatement};`,
   }
 };
 
-// src/restura/restura.ts
-import { types } from "pg";
-
 // src/restura/sql/PsqlPool.ts
-import { Pool } from "pg";
+import pg from "pg";
+import format3 from "pg-format";
+var { Pool } = pg;
 var PsqlPool = class {
   constructor(poolConfig) {
     this.poolConfig = poolConfig;
     this.pool = new Pool(poolConfig);
+    this.queryOne("SELECT NOW();", [], { isSystemUser: true, role: "", host: "localhost", ipAddress: "" }).then(() => {
+      logger.info("Connected to PostgreSQL database");
+    }).catch((error) => {
+      logger.error("Error connecting to database", error);
+      process.exit(1);
+    });
   }
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  async queryOne(query, options) {
+  async queryOne(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
+    this.logSqlStatement(formattedQuery, options, requesterDetails);
     try {
       const response = await this.pool.query(formattedQuery, options);
+      if (response.rows.length === 0) throw new RsError("NOT_FOUND", "No results found");
+      else if (response.rows.length > 1) throw new RsError("DUPLICATE", "More than one result found");
       return response.rows[0];
     } catch (error) {
       console.error(error, query, options);
+      if (RsError.isRsError(error)) throw error;
       if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
         throw new RsError("DUPLICATE", error.message);
       }
@@ -1592,8 +1719,9 @@ var PsqlPool = class {
     }
   }
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  async runQuery(query, options) {
+  async runQuery(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
+    this.logSqlStatement(formattedQuery, options, requesterDetails);
     const queryUpdated = query.replace(/[\t\n]/g, " ");
     console.log(queryUpdated, options);
     try {
@@ -1607,9 +1735,30 @@ var PsqlPool = class {
       throw new RsError("DATABASE_ERROR", `${error.message}`);
     }
   }
+  logSqlStatement(query, options, requesterDetails, prefix = "") {
+    if (logger.level !== "silly") return;
+    let sqlStatement = "";
+    if (options.length === 0) {
+      sqlStatement = query;
+    } else {
+      let stringIndex = 0;
+      sqlStatement = query.replace(/\$\d+/g, () => {
+        const value = options[stringIndex++];
+        if (typeof value === "number") return value.toString();
+        return format3.literal(value);
+      });
+    }
+    let initiator = "Anonymous";
+    if ("userId" in requesterDetails && requesterDetails.userId)
+      initiator = `User Id (${requesterDetails.userId.toString()})`;
+    if ("isSystemUser" in requesterDetails && requesterDetails.isSystemUser) initiator = "SYSTEM";
+    logger.silly(`${prefix}query by ${initiator}, Query ->
+ ${sqlStatement}`);
+  }
 };
 
 // src/restura/restura.ts
+var { types } = pg2;
 var ResturaEngine = class {
   constructor() {
     this.publicEndpoints = {
@@ -1627,10 +1776,11 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the initialization is complete.
    */
   async init(app, authenticationHandler, psqlConnectionPool) {
+    this.resturaConfig = config2.validate("restura", resturaConfigSchema);
     this.psqlConnectionPool = psqlConnectionPool;
     this.psqlEngine = new PsqlEngine(this.psqlConnectionPool);
     setupPgReturnTypes();
-    this.resturaConfig = config2.validate("restura", resturaConfigSchema);
+    await customApiFactory_default.loadApiFiles(this.resturaConfig.customApiFolderPath);
     this.authenticationHandler = authenticationHandler;
     app.use(compression());
     app.use(bodyParser.json({ limit: "32mb" }));
@@ -1693,7 +1843,7 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the API has been successfully generated and written to the output file.
    */
   async generateApiFromSchema(outputFile, providedSchema) {
-    fs2.writeFileSync(
+    fs3.writeFileSync(
       outputFile,
       await apiGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
     );
@@ -1706,7 +1856,7 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the model has been successfully written to the output file.
    */
   async generateModelFromSchema(outputFile, providedSchema) {
-    fs2.writeFileSync(
+    fs3.writeFileSync(
       outputFile,
       await modelGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
     );
@@ -1718,11 +1868,11 @@ var ResturaEngine = class {
    * @throws {Error} If the schema file is missing or the schema is not valid.
    */
   async getLatestFileSystemSchema() {
-    if (!fs2.existsSync(this.resturaConfig.schemaFilePath)) {
+    if (!fs3.existsSync(this.resturaConfig.schemaFilePath)) {
       logger.error(`Missing restura schema file, expected path: ${this.resturaConfig.schemaFilePath}`);
       throw new Error("Missing restura schema file");
     }
-    const schemaFileData = fs2.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
+    const schemaFileData = fs3.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
     const schema = ObjectUtils5.safeParse(schemaFileData);
     const isValid = await isSchemaValid(schema);
     if (!isValid) {
@@ -1743,9 +1893,9 @@ var ResturaEngine = class {
   async getHashes(providedSchema) {
     var _a, _b, _c, _d;
     const schemaHash = await this.generateHashForSchema(providedSchema);
-    const apiFile = fs2.readFileSync(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
+    const apiFile = fs3.readFileSync(path3.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
     const apiCreatedSchemaHash = (_b = (_a = apiFile.toString().match(/\((.*)\)/)) == null ? void 0 : _a[1]) != null ? _b : "";
-    const modelFile = fs2.readFileSync(path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
+    const modelFile = fs3.readFileSync(path3.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
     const modelCreatedSchemaHash = (_d = (_c = modelFile.toString().match(/\((.*)\)/)) == null ? void 0 : _c[1]) != null ? _d : "";
     return {
       schemaHash,
@@ -1781,27 +1931,27 @@ var ResturaEngine = class {
     logger.info(`Restura loaded (${routeCount}) endpoint${routeCount > 1 ? "s" : ""}`);
   }
   async validateGeneratedTypesFolder() {
-    if (!fs2.existsSync(this.resturaConfig.generatedTypesPath)) {
-      fs2.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
+    if (!fs3.existsSync(this.resturaConfig.generatedTypesPath)) {
+      fs3.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
     }
-    const hasApiFile = fs2.existsSync(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const hasModelsFile = fs2.existsSync(path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
+    const hasApiFile = fs3.existsSync(path3.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
+    const hasModelsFile = fs3.existsSync(path3.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
     if (!hasApiFile) {
-      await this.generateApiFromSchema(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+      await this.generateApiFromSchema(path3.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     }
     if (!hasModelsFile) {
       await this.generateModelFromSchema(
-        path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+        path3.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
         this.schema
       );
     }
     const hashes = await this.getHashes(this.schema);
     if (hashes.schemaHash !== hashes.apiCreatedSchemaHash) {
-      await this.generateApiFromSchema(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+      await this.generateApiFromSchema(path3.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     }
     if (hashes.schemaHash !== hashes.modelCreatedSchemaHash) {
       await this.generateModelFromSchema(
-        path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+        path3.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
         this.schema
       );
     }
@@ -1831,9 +1981,9 @@ var ResturaEngine = class {
     }
   }
   async updateTypes() {
-    await this.generateApiFromSchema(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+    await this.generateApiFromSchema(path3.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     await this.generateModelFromSchema(
-      path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+      path3.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
       this.schema
     );
   }
@@ -1856,11 +2006,16 @@ var ResturaEngine = class {
       const routeData = this.getRouteData(req.method, req.baseUrl, req.path);
       this.validateAuthorization(req, 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) {
@@ -1870,34 +2025,25 @@ var ResturaEngine = class {
   isCustomRoute(route) {
     return route.type === "CUSTOM_ONE" || route.type === "CUSTOM_ARRAY" || route.type === "CUSTOM_PAGED";
   }
-  // @boundMethod
-  // private async runCustomRouteLogic<T>(req: RsRequest<T>, res: RsResponse<T>, routeData: 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 += StringUtils.capitalizeFirst(value);
-  // 		return acc;
-  // 	}, '');
-  // 	const customApiName = `${StringUtils.capitalizeFirst(domain)}Api${StringUtils.capitalizeFirst(version)}`;
-  // 	const customApi = apiFactory.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 + StringUtils.capitalizeFirst(cur);
-  // 		}, '')}`;
-  // 	// @ts-expect-error - Here we are dynamically calling the function from a custom class, not sure how to typescript this
-  // 	const customFunction = customApi[functionName] as (
-  // 		req: RsRequest<T>,
-  // 		res: RsResponse<T>,
-  // 		routeData: RouteData
-  // 	) => Promise<void>;
-  // 	if (!customFunction) throw new RsError('NOT_FOUND', `API path ${routeData.path} not implemented`);
-  // 	await customFunction(req, res, routeData);
-  // }
+  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 += StringUtils3.capitalizeFirst(value);
+      return acc;
+    }, "");
+    const customApiName = `${StringUtils3.capitalizeFirst(domain)}Api${StringUtils3.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 + StringUtils3.capitalizeFirst(cur);
+    }, "")}`;
+    const customFunction = customApi[functionName];
+    if (!customFunction) throw new RsError("NOT_FOUND", `API path ${routeData.path} not implemented`);
+    await customFunction(req, res, routeData);
+  }
   async generateHashForSchema(providedSchema) {
     const schemaPrettyStr = await prettier3.format(JSON.stringify(providedSchema), __spreadValues({
       parser: "json"
@@ -1922,7 +2068,7 @@ var ResturaEngine = class {
       printWidth: 120,
       singleQuote: true
     }));
-    fs2.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
+    fs3.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
   }
   resetPublicEndpoints() {
     this.publicEndpoints = {
@@ -1939,13 +2085,13 @@ var ResturaEngine = class {
     if (!routeData.roles.includes(role))
       throw new RsError("UNAUTHORIZED", "Not authorized to access this endpoint");
   }
-  getRouteData(method, baseUrl, path3) {
+  getRouteData(method, baseUrl, path4) {
     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 === path3;
+      return item.method === method && item.path === path4;
     });
     if (!route) throw new RsError("NOT_FOUND", "Route not found");
     return route;
@@ -1972,6 +2118,9 @@ __decorateClass([
 __decorateClass([
   boundMethod
 ], ResturaEngine.prototype, "isCustomRoute", 1);
+__decorateClass([
+  boundMethod
+], ResturaEngine.prototype, "runCustomRouteLogic", 1);
 var setupPgReturnTypes = () => {
   const TIMESTAMPTZ_OID = 1184;
   types.setTypeParser(TIMESTAMPTZ_OID, (val) => {
@@ -1985,8 +2134,16 @@ var setupPgReturnTypes = () => {
 setupPgReturnTypes();
 var restura = new ResturaEngine();
 export {
+  HtmlStatusCodes,
   PsqlPool,
+  RsError,
+  SQL,
+  escapeColumnName,
+  insertObjectQuery,
+  isValueNumber2 as isValueNumber,
   logger,
-  restura
+  questionMarksToOrderedParams,
+  restura,
+  updateObjectQuery
 };
 //# sourceMappingURL=index.mjs.map