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

package/dist/index.mjs

@@ -1,5 +1,7 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -15,6 +17,19 @@ var __spreadValues = (a, b) => {
     }
   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 __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--)
@@ -77,7 +92,7 @@ var logger = winston.createLogger({
 });
 
 // src/restura/restura.ts
-import { ObjectUtils as ObjectUtils3 } from "@redskytech/core-utils";
+import { ObjectUtils as ObjectUtils5 } 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
@@ -132,8 +147,8 @@ import compression from "compression";
 import cookieParser from "cookie-parser";
 import { createHash } from "crypto";
 import * as express from "express";
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import * as prettier3 from "prettier";
 
 // src/restura/errors.ts
@@ -185,7 +200,7 @@ var htmlStatusMap = {
   SCHEMA_ERROR: 500 /* SERVER_ERROR */
 };
 
-// src/restura/SqlUtils.ts
+// src/restura/sql/SqlUtils.ts
 var SqlUtils = class _SqlUtils {
   static convertDatabaseTypeToTypescript(type, value) {
     type = type.toLocaleLowerCase();
@@ -276,9 +291,9 @@ var ResponseValidator = class _ResponseValidator {
     return { validator: "any" };
   }
   getTypeFromTable(selector, name) {
-    const path2 = selector.split(".");
-    if (path2.length === 0 || path2.length > 2 || path2[0] === "") return { validator: "any", isOptional: false };
-    const tableName = path2.length == 2 ? path2[0] : name, columnName = path2.length == 2 ? path2[1] : path2[0];
+    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 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 };
@@ -494,10 +509,10 @@ var ApiTree = class _ApiTree {
     return `${p.name}${optional ? "?" : ""}:${responseType}${array ? "[]" : ""}`;
   }
   getTypeFromTable(selector, name) {
-    const path2 = selector.split(".");
-    if (path2.length === 0 || path2.length > 2 || path2[0] === "") return { responseType: "any", optional: false };
-    let tableName = path2.length == 2 ? path2[0] : name;
-    const columnName = path2.length == 2 ? path2[1] : path2[0];
+    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];
     let table = this.database.find((t) => t.name == tableName);
     if (!table && tableName.includes("_")) {
       const tableAliasSplit = tableName.split("_");
@@ -512,8 +527,8 @@ var ApiTree = class _ApiTree {
     };
   }
 };
-function pathToNamespaces(path2) {
-  return path2.split("/").map((e) => StringUtils.toPascalCasing(e)).filter((e) => e);
+function pathToNamespaces(path3) {
+  return path3.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 **/`;
@@ -577,6 +592,163 @@ function addApiResponseFunctions(req, res, next) {
 // src/restura/validateRequestParams.ts
 import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
 import jsonschema from "jsonschema";
+import { z as z3 } from "zod";
+
+// src/restura/types/validation.types.ts
+import { z as z2 } from "zod";
+var validatorDataSchemeValue = z2.union([z2.string(), z2.array(z2.string()), z2.number(), z2.array(z2.number())]);
+var validatorDataSchema = z2.object({
+  type: z2.enum(["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]),
+  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") {
@@ -611,84 +783,83 @@ function getRequestData(req) {
 }
 
 // src/restura/restura.schema.ts
-import { z as z2 } from "zod";
-var orderBySchema = z2.object({
-  columnName: z2.string(),
-  order: z2.enum(["ASC", "DESC"]),
-  tableName: z2.string()
+import { z as z4 } from "zod";
+var orderBySchema = z4.object({
+  columnName: z4.string(),
+  order: z4.enum(["ASC", "DESC"]),
+  tableName: z4.string()
 }).strict();
-var groupBySchema = z2.object({
-  columnName: z2.string(),
-  tableName: z2.string()
+var groupBySchema = z4.object({
+  columnName: z4.string(),
+  tableName: z4.string()
 }).strict();
-var whereDataSchema = z2.object({
-  tableName: z2.string().optional(),
-  columnName: z2.string().optional(),
-  operator: z2.enum(["=", "<", ">", "<=", ">=", "!=", "LIKE", "IN", "NOT IN", "STARTS WITH", "ENDS WITH"]).optional(),
-  value: z2.string().optional(),
-  custom: z2.string().optional(),
-  conjunction: z2.enum(["AND", "OR"]).optional()
+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()
 }).strict();
-var assignmentDataSchema = z2.object({
-  name: z2.string(),
-  value: z2.string()
+var assignmentDataSchema = z4.object({
+  name: z4.string(),
+  value: z4.string()
 }).strict();
-var joinDataSchema = z2.object({
-  table: z2.string(),
-  localColumnName: z2.string().optional(),
-  foreignColumnName: z2.string().optional(),
-  custom: z2.string().optional(),
-  type: z2.enum(["LEFT", "INNER"]),
-  alias: z2.string().optional()
+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()
 }).strict();
-var validatorDataSchema = z2.object({
-  type: z2.enum(["TYPE_CHECK", "MIN", "MAX", "ONE_OF"]),
-  value: z2.union([z2.string(), z2.array(z2.string()), z2.number(), z2.array(z2.number())])
+var requestDataSchema = z4.object({
+  name: z4.string(),
+  required: z4.boolean(),
+  validator: z4.array(validatorDataSchema)
 }).strict();
-var requestDataSchema = z2.object({
-  name: z2.string(),
-  required: z2.boolean(),
-  validator: z2.array(validatorDataSchema)
-}).strict();
-var responseDataSchema = z2.object({
-  name: z2.string(),
-  selector: z2.string().optional(),
-  subquery: z2.object({
-    table: z2.string(),
-    joins: z2.array(joinDataSchema),
-    where: z2.array(whereDataSchema),
-    properties: z2.array(z2.lazy(() => responseDataSchema)),
+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)),
     // Explicit type for the lazy schema
     groupBy: groupBySchema.optional(),
     orderBy: orderBySchema.optional()
   }).optional()
 }).strict();
-var routeDataBaseSchema = z2.object({
-  method: z2.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]),
-  name: z2.string(),
-  description: z2.string(),
-  path: z2.string(),
-  roles: z2.array(z2.string())
+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())
 }).strict();
 var standardRouteSchema = routeDataBaseSchema.extend({
-  type: z2.enum(["ONE", "ARRAY", "PAGED"]),
-  table: z2.string(),
-  joins: z2.array(joinDataSchema),
-  assignments: z2.array(assignmentDataSchema),
-  where: z2.array(whereDataSchema),
-  request: z2.array(requestDataSchema),
-  response: z2.array(responseDataSchema),
+  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),
   groupBy: groupBySchema.optional(),
   orderBy: orderBySchema.optional()
 }).strict();
 var customRouteSchema = routeDataBaseSchema.extend({
-  type: z2.enum(["CUSTOM_ONE", "CUSTOM_ARRAY", "CUSTOM_PAGED"]),
-  responseType: z2.union([z2.string(), z2.enum(["string", "number", "boolean"])]),
-  requestType: z2.string().optional(),
-  request: z2.array(requestDataSchema).optional(),
-  fileUploadType: z2.enum(["SINGLE", "MULTIPLE"]).optional()
+  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()
 }).strict();
-var postgresColumnNumericTypesSchema = z2.enum([
+var postgresColumnNumericTypesSchema = z4.enum([
   "SMALLINT",
   // 2 bytes, -32,768 to 32,767
   "INTEGER",
@@ -708,7 +879,7 @@ var postgresColumnNumericTypesSchema = z2.enum([
   "BIGSERIAL"
   // auto-incrementing big integer
 ]);
-var postgresColumnStringTypesSchema = z2.enum([
+var postgresColumnStringTypesSchema = z4.enum([
   "CHAR",
   // fixed-length, blank-padded
   "VARCHAR",
@@ -718,7 +889,7 @@ var postgresColumnStringTypesSchema = z2.enum([
   "BYTEA"
   // binary data
 ]);
-var postgresColumnDateTypesSchema = z2.enum([
+var postgresColumnDateTypesSchema = z4.enum([
   "DATE",
   // calendar date (year, month, day)
   "TIMESTAMP",
@@ -730,7 +901,7 @@ var postgresColumnDateTypesSchema = z2.enum([
   "INTERVAL"
   // time span
 ]);
-var mariaDbColumnNumericTypesSchema = z2.enum([
+var mariaDbColumnNumericTypesSchema = z4.enum([
   "BOOLEAN",
   // 1-byte A synonym for "TINYINT(1)". Supported from version 1.2.0 onwards.
   "TINYINT",
@@ -750,7 +921,7 @@ var mariaDbColumnNumericTypesSchema = z2.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 = z2.enum([
+var mariaDbColumnStringTypesSchema = z4.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",
@@ -776,7 +947,7 @@ var mariaDbColumnStringTypesSchema = z2.enum([
   "ENUM"
   // Enum type
 ]);
-var mariaDbColumnDateTypesSchema = z2.enum([
+var mariaDbColumnDateTypesSchema = z4.enum([
   "DATE",
   // 4-bytes Date has year, month, and day.
   "DATETIME",
@@ -786,9 +957,9 @@ var mariaDbColumnDateTypesSchema = z2.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 = z2.object({
-  name: z2.string(),
-  type: z2.union([
+var columnDataSchema = z4.object({
+  name: z4.string(),
+  type: z4.union([
     postgresColumnNumericTypesSchema,
     postgresColumnStringTypesSchema,
     postgresColumnDateTypesSchema,
@@ -796,24 +967,24 @@ var columnDataSchema = z2.object({
     mariaDbColumnStringTypesSchema,
     mariaDbColumnDateTypesSchema
   ]),
-  isNullable: z2.boolean(),
-  roles: z2.array(z2.string()),
-  comment: z2.string().optional(),
-  default: z2.string().optional(),
-  value: z2.string().optional(),
-  isPrimary: z2.boolean().optional(),
-  isUnique: z2.boolean().optional(),
-  hasAutoIncrement: z2.boolean().optional(),
-  length: z2.number().optional()
+  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()
 }).strict();
-var indexDataSchema = z2.object({
-  name: z2.string(),
-  columns: z2.array(z2.string()),
-  isUnique: z2.boolean(),
-  isPrimaryKey: z2.boolean(),
-  order: z2.enum(["ASC", "DESC"])
+var indexDataSchema = z4.object({
+  name: z4.string(),
+  columns: z4.array(z4.string()),
+  isUnique: z4.boolean(),
+  isPrimaryKey: z4.boolean(),
+  order: z4.enum(["ASC", "DESC"])
 }).strict();
-var foreignKeyActionsSchema = z2.enum([
+var foreignKeyActionsSchema = z4.enum([
   "CASCADE",
   // CASCADE action for foreign keys
   "SET NULL",
@@ -825,38 +996,38 @@ var foreignKeyActionsSchema = z2.enum([
   "SET DEFAULT"
   // SET DEFAULT action for foreign keys
 ]);
-var foreignKeyDataSchema = z2.object({
-  name: z2.string(),
-  column: z2.string(),
-  refTable: z2.string(),
-  refColumn: z2.string(),
+var foreignKeyDataSchema = z4.object({
+  name: z4.string(),
+  column: z4.string(),
+  refTable: z4.string(),
+  refColumn: z4.string(),
   onDelete: foreignKeyActionsSchema,
   onUpdate: foreignKeyActionsSchema
 }).strict();
-var checkConstraintDataSchema = z2.object({
-  name: z2.string(),
-  check: z2.string()
+var checkConstraintDataSchema = z4.object({
+  name: z4.string(),
+  check: z4.string()
 }).strict();
-var tableDataSchema = z2.object({
-  name: z2.string(),
-  columns: z2.array(columnDataSchema),
-  indexes: z2.array(indexDataSchema),
-  foreignKeys: z2.array(foreignKeyDataSchema),
-  checkConstraints: z2.array(checkConstraintDataSchema),
-  roles: z2.array(z2.string())
+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())
 }).strict();
-var endpointDataSchema = z2.object({
-  name: z2.string(),
-  description: z2.string(),
-  baseUrl: z2.string(),
-  routes: z2.array(z2.union([standardRouteSchema, customRouteSchema]))
+var endpointDataSchema = z4.object({
+  name: z4.string(),
+  description: z4.string(),
+  baseUrl: z4.string(),
+  routes: z4.array(z4.union([standardRouteSchema, customRouteSchema]))
 }).strict();
-var resturaZodSchema = z2.object({
-  database: z2.array(tableDataSchema),
-  endpoints: z2.array(endpointDataSchema),
-  globalParams: z2.array(z2.string()),
-  roles: z2.array(z2.string()),
-  customTypes: z2.string()
+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()
 }).strict();
 async function isSchemaValid(schemaToCheck) {
   try {
@@ -916,7 +1087,7 @@ function convertTable(table) {
 }
 
 // src/restura/middleware/authenticateUser.ts
-async function authenticateUser(applicationAuthenticateHandler) {
+function authenticateUser(applicationAuthenticateHandler) {
   return (req, res, next) => {
     applicationAuthenticateHandler(
       req,
@@ -931,6 +1102,513 @@ async function authenticateUser(applicationAuthenticateHandler) {
   };
 }
 
+// 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 || {};
+  });
+  temporaryFile.removeCallback();
+  return schemaObject;
+}
+
+// src/restura/sql/SqlEngine.ts
+import { ObjectUtils as ObjectUtils3 } from "@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 = ObjectUtils3.isArrayWithData(columnSchema.roles);
+      if (!doesColumnHaveRoles) return true;
+      if (!role) return false;
+      return columnSchema.roles.includes(role);
+    }
+    if (item.subquery) {
+      return ObjectUtils3.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 = ObjectUtils3.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 _a;
+    if (!routeData.request) return value;
+    const data = req.data;
+    if (typeof value === "string") {
+      (_a = value.match(/\$[a-zA-Z][a-zA-Z0-9_]+/g)) == null ? void 0 : _a.forEach((param) => {
+        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 _a;
+    if (typeof value === "string") {
+      (_a = value.match(/#[a-zA-Z][a-zA-Z0-9_]+/g)) == null ? void 0 : _a.forEach((param) => {
+        param = param.replace("#", "");
+        const globalParamValue = req.requesterDetails[param];
+        if (!globalParamValue)
+          throw new RsError("SCHEMA_ERROR", `Invalid global keyword clause in route ${routeData.name}`);
+        sqlParams.push(globalParamValue);
+      });
+      return value.replace(new RegExp(/#[a-zA-Z][a-zA-Z0-9_]+/g), "?");
+    }
+    return value;
+  }
+};
+
+// src/restura/sql/filterSqlParser.ts
+import peg from "pegjs";
+var filterSqlGrammar = `
+start = expressionList
+
+expressionList =
+        leftExpression:expression operator:operator rightExpression:expressionList 
+    { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
+    / expression
+
+expression = 
+    negate:negate?"(" "column:" column:column ","? value:value? ","? type:type? ")" 
+    {return \`\${negate? "!" : ""}(\${type?  type(column, value) : \`\${column} = \${mysql.escape(value)}\`})\`;}
+    /
+    negate:negate?"("expression:expressionList")" { return \`\${negate? "!" : ""}(\${expression})\`; }
+
+negate = "!"
+    
+operator = "and"i / "or"i
+
+column = left:text "." right:text { return  \`\${mysql.escapeId(left)}.\${mysql.escapeId(right)}\`; }
+	   /
+	   text:text { return mysql.escapeId(text); }
+
+
+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)}'\`; } } / 
+    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 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;
+}
+
+// src/restura/sql/PsqlEngine.ts
+var PsqlEngine = class extends SqlEngine {
+  constructor(psqlConnectionPool) {
+    super();
+    this.psqlConnectionPool = psqlConnectionPool;
+  }
+  async diffDatabaseToSchema(schema) {
+    console.log(schema);
+    return Promise.resolve("");
+  }
+  generateDatabaseSchemaFromSchema(schema) {
+    console.log(schema);
+    return "";
+  }
+  createNestedSelect(req, schema, item, routeData, userRole, sqlParams) {
+    console.log(req, schema, item, routeData, userRole, sqlParams);
+    return "";
+  }
+  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);
+    const insertId = createdItem == null ? void 0 : createdItem.id;
+    const whereData = [
+      {
+        tableName: routeData.table,
+        value: insertId,
+        columnName: "id",
+        operator: "="
+      }
+    ];
+    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 ${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
+      );
+    } else if (routeData.type === "ARRAY") {
+      return this.psqlConnectionPool.runQuery(
+        `${selectStatement}${sqlStatement}${groupByOrderByStatement};`,
+        sqlParams
+      );
+    } else if (routeData.type === "PAGED") {
+      const data = req.data;
+      const pageResults = await this.psqlConnectionPool.runQuery(
+        `${selectStatement}${sqlStatement}${groupByOrderByStatement} LIMIT ? OFFSET ?;SELECT COUNT(${routeData.groupBy ? `DISTINCT ${routeData.groupBy.tableName}.${routeData.groupBy.columnName}` : "*"}) AS total
+${sqlStatement};`,
+        [
+          ...sqlParams,
+          data.perPage || DEFAULT_PAGED_PER_PAGE_NUMBER,
+          (data.page - 1) * data.perPage || DEFAULT_PAGED_PAGE_NUMBER,
+          ...sqlParams
+        ]
+      );
+      let total = 0;
+      if (ObjectUtils4.isArrayWithData(pageResults)) {
+        total = pageResults[1][0].total;
+      }
+      return { data: pageResults[0], total };
+    } else {
+      throw new RsError("UNKNOWN_ERROR", "Unknown route type.");
+    }
+  }
+  async executeUpdateRequest(req, routeData, schema) {
+    const sqlParams = [];
+    const _a = req.body, { id } = _a, bodyNoId = __objRest(_a, ["id"]);
+    const 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]);
+    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
+    );
+    let deleteStatement = `DELETE
+                           FROM "${routeData.table}" ${joinStatement}`;
+    deleteStatement += this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    deleteStatement += ";";
+    await this.psqlConnectionPool.runQuery(deleteStatement, sqlParams);
+    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 {};
+  }
+  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") {
+        sqlParams[sqlParams.length - 1] = `%${sqlParams[sqlParams.length - 1]}%`;
+      } else if (operator === "STARTS WITH") {
+        operator = "LIKE";
+        sqlParams[sqlParams.length - 1] = `${sqlParams[sqlParams.length - 1]}%`;
+      } else if (operator === "ENDS WITH") {
+        operator = "LIKE";
+        sqlParams[sqlParams.length - 1] = `%${sqlParams[sqlParams.length - 1]}`;
+      }
+      const replacedValue = this.replaceParamKeywords(item.value, routeData, req, sqlParams);
+      const escapedValue = SQL`${replacedValue}`;
+      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator} ${["IN", "NOT IN"].includes(operator) ? `(${escapedValue})` : escapedValue}
+`;
+    });
+    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) => {
+        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];
+      });
+      statement = statement.replace(/#[a-zA-Z][a-zA-Z0-9_]+/g, (value) => {
+        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];
+      });
+      statement = filterSqlParser_default.parse(statement);
+      if (whereClause.startsWith("WHERE")) {
+        whereClause += ` AND (${statement})
+`;
+      } else {
+        whereClause += `WHERE ${statement}
+`;
+      }
+    }
+    return whereClause;
+  }
+};
+
+// src/restura/restura.ts
+import { types } from "pg";
+
+// src/restura/sql/PsqlPool.ts
+import { Pool } from "pg";
+var PsqlPool = class {
+  constructor(poolConfig) {
+    this.poolConfig = poolConfig;
+    this.pool = new Pool(poolConfig);
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  async queryOne(query, options) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    try {
+      const response = await this.pool.query(formattedQuery, options);
+      return response.rows[0];
+    } 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}`);
+    }
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  async runQuery(query, options) {
+    const formattedQuery = questionMarksToOrderedParams(query);
+    const queryUpdated = query.replace(/[\t\n]/g, " ");
+    console.log(queryUpdated, options);
+    try {
+      const response = await this.pool.query(formattedQuery, options);
+      return response.rows;
+    } catch (error) {
+      console.error(error, query, options);
+      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+};
+
 // src/restura/restura.ts
 var ResturaEngine = class {
   constructor() {
@@ -942,14 +1620,16 @@ var ResturaEngine = class {
       DELETE: []
     };
   }
-  // private customTypeValidation!: ValidationDictionary;
   /**
    * 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) {
+  async init(app, authenticationHandler, psqlConnectionPool) {
+    this.psqlConnectionPool = psqlConnectionPool;
+    this.psqlEngine = new PsqlEngine(this.psqlConnectionPool);
+    setupPgReturnTypes();
     this.resturaConfig = config2.validate("restura", resturaConfigSchema);
     this.authenticationHandler = authenticationHandler;
     app.use(compression());
@@ -958,7 +1638,7 @@ var ResturaEngine = class {
     app.use(cookieParser());
     app.disable("x-powered-by");
     app.use("/", addApiResponseFunctions);
-    app.use("/api/", authenticateUser);
+    app.use("/api/", authenticateUser(this.authenticationHandler));
     app.use("/restura", this.resturaAuthentication);
     app.put(
       "/restura/v1/schema",
@@ -974,7 +1654,7 @@ var ResturaEngine = class {
     app.get("/restura/v1/schema/types", this.getSchemaAndTypes);
     this.expressApp = app;
     await this.reloadEndpoints();
-    this.validateGeneratedTypesFolder();
+    await this.validateGeneratedTypesFolder();
     logger.info("Restura Engine Initialized");
   }
   /**
@@ -1013,7 +1693,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) {
-    fs.writeFileSync(
+    fs2.writeFileSync(
       outputFile,
       await apiGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
     );
@@ -1026,7 +1706,7 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the model has been successfully written to the output file.
    */
   async generateModelFromSchema(outputFile, providedSchema) {
-    fs.writeFileSync(
+    fs2.writeFileSync(
       outputFile,
       await modelGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
     );
@@ -1038,12 +1718,12 @@ var ResturaEngine = class {
    * @throws {Error} If the schema file is missing or the schema is not valid.
    */
   async getLatestFileSystemSchema() {
-    if (!fs.existsSync(this.resturaConfig.schemaFilePath)) {
+    if (!fs2.existsSync(this.resturaConfig.schemaFilePath)) {
       logger.error(`Missing restura schema file, expected path: ${this.resturaConfig.schemaFilePath}`);
       throw new Error("Missing restura schema file");
     }
-    const schemaFileData = fs.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
-    const schema = ObjectUtils3.safeParse(schemaFileData);
+    const schemaFileData = fs2.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
+    const schema = ObjectUtils5.safeParse(schemaFileData);
     const isValid = await isSchemaValid(schema);
     if (!isValid) {
       logger.error("Schema is not valid");
@@ -1063,9 +1743,9 @@ var ResturaEngine = class {
   async getHashes(providedSchema) {
     var _a, _b, _c, _d;
     const schemaHash = await this.generateHashForSchema(providedSchema);
-    const apiFile = fs.readFileSync(path.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
+    const apiFile = fs2.readFileSync(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
     const apiCreatedSchemaHash = (_b = (_a = apiFile.toString().match(/\((.*)\)/)) == null ? void 0 : _a[1]) != null ? _b : "";
-    const modelFile = fs.readFileSync(path.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
+    const modelFile = fs2.readFileSync(path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
     const modelCreatedSchemaHash = (_d = (_c = modelFile.toString().match(/\((.*)\)/)) == null ? void 0 : _c[1]) != null ? _d : "";
     return {
       schemaHash,
@@ -1075,6 +1755,7 @@ var ResturaEngine = class {
   }
   async reloadEndpoints() {
     this.schema = await this.getLatestFileSystemSchema();
+    this.customTypeValidation = customTypeValidationGenerator(this.schema);
     this.resturaRouter = express.Router();
     this.resetPublicEndpoints();
     let routeCount = 0;
@@ -1100,27 +1781,27 @@ var ResturaEngine = class {
     logger.info(`Restura loaded (${routeCount}) endpoint${routeCount > 1 ? "s" : ""}`);
   }
   async validateGeneratedTypesFolder() {
-    if (!fs.existsSync(this.resturaConfig.generatedTypesPath)) {
-      fs.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
+    if (!fs2.existsSync(this.resturaConfig.generatedTypesPath)) {
+      fs2.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
     }
-    const hasApiFile = fs.existsSync(path.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const hasModelsFile = fs.existsSync(path.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
+    const hasApiFile = fs2.existsSync(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
+    const hasModelsFile = fs2.existsSync(path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
     if (!hasApiFile) {
-      await this.generateApiFromSchema(path.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+      await this.generateApiFromSchema(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     }
     if (!hasModelsFile) {
       await this.generateModelFromSchema(
-        path.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+        path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
         this.schema
       );
     }
     const hashes = await this.getHashes(this.schema);
     if (hashes.schemaHash !== hashes.apiCreatedSchemaHash) {
-      await this.generateApiFromSchema(path.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+      await this.generateApiFromSchema(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     }
     if (hashes.schemaHash !== hashes.modelCreatedSchemaHash) {
       await this.generateModelFromSchema(
-        path.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+        path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
         this.schema
       );
     }
@@ -1150,9 +1831,9 @@ var ResturaEngine = class {
     }
   }
   async updateTypes() {
-    await this.generateApiFromSchema(path.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
+    await this.generateApiFromSchema(path2.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
     await this.generateModelFromSchema(
-      path.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
+      path2.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
       this.schema
     );
   }
@@ -1174,6 +1855,14 @@ var ResturaEngine = class {
     try {
       const routeData = this.getRouteData(req.method, req.baseUrl, req.path);
       this.validateAuthorization(req, routeData);
+      validateRequestParams(req, routeData, this.customTypeValidation);
+      const data = await this.psqlEngine.runQueryForRoute(
+        req,
+        routeData,
+        this.schema
+      );
+      if (routeData.type === "PAGED") res.sendNoWrap(data);
+      else res.sendData(data);
     } catch (e) {
       next(e);
     }
@@ -1233,7 +1922,7 @@ var ResturaEngine = class {
       printWidth: 120,
       singleQuote: true
     }));
-    fs.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
+    fs2.writeFileSync(this.resturaConfig.schemaFilePath, schemaPrettyStr);
   }
   resetPublicEndpoints() {
     this.publicEndpoints = {
@@ -1250,13 +1939,13 @@ var ResturaEngine = class {
     if (!routeData.roles.includes(role))
       throw new RsError("UNAUTHORIZED", "Not authorized to access this endpoint");
   }
-  getRouteData(method, baseUrl, path2) {
+  getRouteData(method, baseUrl, path3) {
     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 === path2;
+      return item.method === method && item.path === path3;
     });
     if (!route) throw new RsError("NOT_FOUND", "Route not found");
     return route;
@@ -1283,8 +1972,20 @@ __decorateClass([
 __decorateClass([
   boundMethod
 ], ResturaEngine.prototype, "isCustomRoute", 1);
+var setupPgReturnTypes = () => {
+  const TIMESTAMPTZ_OID = 1184;
+  types.setTypeParser(TIMESTAMPTZ_OID, (val) => {
+    return val === null ? null : new Date(val).toISOString();
+  });
+  const BIGINT_OID = 20;
+  types.setTypeParser(BIGINT_OID, (val) => {
+    return val === null ? null : Number(val);
+  });
+};
+setupPgReturnTypes();
 var restura = new ResturaEngine();
 export {
+  PsqlPool,
   logger,
   restura
 };