@restura/core 0.1.0-alpha.24 → 0.1.0-alpha.25

package/dist/index.mjs

@@ -44,23 +44,11 @@ import { config } from "@restura/internal";
 import winston from "winston";
 import { format } from "logform";
 
-// src/config.schema.ts
+// src/logger/loggerConfigSchema.ts
 import { z } from "zod";
 var loggerConfigSchema = z.object({
   level: z.enum(["info", "warn", "error", "debug", "silly"]).default("info")
 });
-var _a;
-var isTsx = (_a = process.argv[1]) == null ? void 0 : _a.endsWith(".ts");
-var isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
-var customApiFolderPath = isTsx || isTsNode ? "/src/api" : "/dist/api";
-var resturaConfigSchema = 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() + customApiFolderPath),
-  generatedTypesPath: z.string().default(process.cwd() + "/src/@types"),
-  fileTempCachePath: z.string().optional()
-});
 
 // src/logger/logger.ts
 var loggerConfig = config.validate("logger", loggerConfigSchema);
@@ -97,7 +85,194 @@ var logger = winston.createLogger({
   ]
 });
 
-// src/restura/errors.ts
+// src/restura/eventManager.ts
+import Bluebird from "bluebird";
+var EventManager = class {
+  constructor() {
+    this.actionHandlers = {
+      DATABASE_ROW_DELETE: [],
+      DATABASE_ROW_INSERT: [],
+      DATABASE_COLUMN_UPDATE: []
+    };
+  }
+  addRowInsertHandler(onInsert, filter) {
+    this.actionHandlers.DATABASE_ROW_INSERT.push({
+      callback: onInsert,
+      filter
+    });
+  }
+  addColumnChangeHandler(onUpdate, filter) {
+    this.actionHandlers.DATABASE_COLUMN_UPDATE.push({
+      callback: onUpdate,
+      filter
+    });
+  }
+  addRowDeleteHandler(onDelete, filter) {
+    this.actionHandlers.DATABASE_ROW_DELETE.push({
+      callback: onDelete,
+      filter
+    });
+  }
+  async fireActionFromDbTrigger(sqlMutationData, result) {
+    if (sqlMutationData.mutationType === "INSERT") {
+      await this.fireInsertActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "UPDATE") {
+      await this.fireUpdateActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "DELETE") {
+      await this.fireDeleteActions(sqlMutationData, result);
+    }
+  }
+  async fireInsertActions(data, triggerResult) {
+    await Bluebird.map(
+      this.actionHandlers.DATABASE_ROW_INSERT,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
+        const insertData = {
+          tableName: triggerResult.table,
+          insertId: triggerResult.record.id,
+          insertObject: triggerResult.record,
+          queryMetadata: data.queryMetadata
+        };
+        callback(insertData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireDeleteActions(data, triggerResult) {
+    await Bluebird.map(
+      this.actionHandlers.DATABASE_ROW_DELETE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
+        const deleteData = {
+          tableName: triggerResult.table,
+          deletedRow: triggerResult.previousRecord,
+          queryMetadata: data.queryMetadata
+        };
+        callback(deleteData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireUpdateActions(data, triggerResult) {
+    await Bluebird.map(
+      this.actionHandlers.DATABASE_COLUMN_UPDATE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
+        const columnChangeData = {
+          tableName: triggerResult.table,
+          rowId: triggerResult.record.id,
+          newData: triggerResult.record,
+          oldData: triggerResult.previousRecord,
+          queryMetadata: data.queryMetadata
+        };
+        callback(columnChangeData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  hasHandlersForEventType(eventType, filter, triggerResult) {
+    if (filter) {
+      switch (eventType) {
+        case "DATABASE_ROW_INSERT":
+        case "DATABASE_ROW_DELETE":
+          if (filter.tableName && filter.tableName !== triggerResult.table) return false;
+          break;
+        case "DATABASE_COLUMN_UPDATE":
+          const filterColumnChange = filter;
+          if (filterColumnChange.tableName !== filter.tableName) return false;
+          if (!filterColumnChange.columns.some((item) => {
+            const updatedColumns = Object.keys(
+              changedValues(triggerResult.record, triggerResult.previousRecord)
+            );
+            return updatedColumns.includes(item);
+          }))
+            return false;
+          break;
+      }
+    }
+    return true;
+  }
+};
+var eventManager = new EventManager();
+var eventManager_default = eventManager;
+function changedValues(record, previousRecord) {
+  const changed = {};
+  for (const i in previousRecord) {
+    if (previousRecord[i] !== record[i]) {
+      if (typeof previousRecord[i] === "object" && typeof record[i] === "object") {
+        const nestedChanged = changedValues(record[i], previousRecord[i]);
+        if (Object.keys(nestedChanged).length > 0) {
+          changed[i] = record[i];
+        }
+      } else {
+        changed[i] = record[i];
+      }
+    }
+  }
+  return changed;
+}
+
+// src/restura/restura.ts
+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
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+function boundMethod(target, key, descriptor) {
+  var fn = descriptor.value;
+  if (typeof fn !== "function") {
+    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
+  }
+  var definingProperty = false;
+  return {
+    configurable: true,
+    get: function get() {
+      if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== "function") {
+        return fn;
+      }
+      var boundFn = fn.bind(this);
+      definingProperty = true;
+      Object.defineProperty(this, key, {
+        configurable: true,
+        get: function get2() {
+          return boundFn;
+        },
+        set: function set(value) {
+          fn = value;
+          delete this[key];
+        }
+      });
+      definingProperty = false;
+      return boundFn;
+    },
+    set: function set(value) {
+      fn = value;
+    }
+  };
+}
+
+// src/restura/restura.ts
+import bodyParser from "body-parser";
+import compression from "compression";
+import cookieParser from "cookie-parser";
+import * as express from "express";
+import fs4 from "fs";
+import path4 from "path";
+import pg3 from "pg";
+import * as prettier3 from "prettier";
+
+// src/restura/RsError.ts
 var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
   HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
   HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
@@ -121,7 +296,6 @@ var RsError = class _RsError {
   static htmlStatus(code) {
     return htmlStatusMap[code];
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isRsError(error) {
     return error instanceof _RsError;
   }
@@ -163,66 +337,158 @@ var htmlStatusMap = {
   SCHEMA_ERROR: 500 /* SERVER_ERROR */
 };
 
-// src/restura/restura.ts
-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
-function _typeof(obj) {
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function _typeof2(obj2) {
-      return typeof obj2;
-    };
-  } else {
-    _typeof = function _typeof2(obj2) {
-      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    };
-  }
-  return _typeof(obj);
-}
-function boundMethod(target, key, descriptor) {
-  var fn = descriptor.value;
-  if (typeof fn !== "function") {
-    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
+// src/restura/compareSchema.ts
+import cloneDeep from "lodash.clonedeep";
+var CompareSchema = class {
+  async diffSchema(newSchema, latestSchema, psqlEngine) {
+    const endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
+    const globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
+    const roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
+    let commands = "";
+    if (JSON.stringify(newSchema.database) !== JSON.stringify(latestSchema.database))
+      commands = await psqlEngine.diffDatabaseToSchema(newSchema);
+    const customTypes = newSchema.customTypes !== latestSchema.customTypes;
+    const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
+    return schemaPreview;
   }
-  var definingProperty = false;
-  return {
-    configurable: true,
-    get: function get() {
-      if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== "function") {
-        return fn;
+  diffStringArray(newArray, originalArray) {
+    const stringsDiff = [];
+    const originalClone = new Set(originalArray);
+    newArray.forEach((item) => {
+      const originalIndex = originalClone.has(item);
+      if (!originalIndex) {
+        stringsDiff.push({
+          name: item,
+          changeType: "NEW"
+        });
+      } else {
+        originalClone.delete(item);
       }
-      var boundFn = fn.bind(this);
-      definingProperty = true;
-      Object.defineProperty(this, key, {
-        configurable: true,
-        get: function get2() {
-          return boundFn;
-        },
-        set: function set(value) {
-          fn = value;
-          delete this[key];
+    });
+    originalClone.forEach((item) => {
+      stringsDiff.push({
+        name: item,
+        changeType: "DELETED"
+      });
+    });
+    return stringsDiff;
+  }
+  diffEndPoints(newEndPoints, originalEndpoints) {
+    const originalClone = cloneDeep(originalEndpoints);
+    const diffObj = [];
+    newEndPoints.forEach((endPoint) => {
+      const { path: path5, method } = endPoint;
+      const endPointIndex = originalClone.findIndex((original) => {
+        return original.path === endPoint.path && original.method === endPoint.method;
+      });
+      if (endPointIndex === -1) {
+        diffObj.push({
+          name: `${method} ${path5}`,
+          changeType: "NEW"
+        });
+      } else {
+        const original = originalClone.findIndex((original2) => {
+          return this.compareEndPoints(endPoint, original2);
+        });
+        if (original === -1) {
+          diffObj.push({
+            name: `${method} ${path5}`,
+            changeType: "MODIFIED"
+          });
         }
+        originalClone.splice(endPointIndex, 1);
+      }
+    });
+    originalClone.forEach((original) => {
+      const { path: path5, method } = original;
+      diffObj.push({
+        name: `${method} ${path5}`,
+        changeType: "DELETED"
       });
-      definingProperty = false;
-      return boundFn;
-    },
-    set: function set(value) {
-      fn = value;
+    });
+    return diffObj;
+  }
+  compareEndPoints(endPoint1, endPoint2) {
+    return JSON.stringify(endPoint1) === JSON.stringify(endPoint2);
+  }
+};
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffSchema", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffStringArray", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffEndPoints", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "compareEndPoints", 1);
+var compareSchema = new CompareSchema();
+var compareSchema_default = compareSchema;
+
+// src/restura/customApiFactory.ts
+import { fileUtils } from "@restura/internal";
+import Bluebird2 from "bluebird";
+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);
+      const directoryExists = await fileUtils.existDir(apiVersionFolderPath);
+      if (!directoryExists) continue;
+      await this.addDirectory(apiVersionFolderPath, apiVersion);
     }
-  };
-}
+  }
+  getCustomApi(customApiName) {
+    return this.customApis[customApiName];
+  }
+  async addDirectory(directoryPath, apiVersion) {
+    var _a2;
+    const entries = await fs.promises.readdir(directoryPath, {
+      withFileTypes: true
+    });
+    const isTsx2 = (_a2 = process.argv[1]) == null ? void 0 : _a2.endsWith(".ts");
+    const isTsNode2 = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
+    const extension = isTsx2 || isTsNode2 ? "ts" : "js";
+    const shouldEndWith = `.api.${apiVersion}.${extension}`;
+    await Bluebird2.map(entries, async (entry) => {
+      if (entry.isFile()) {
+        if (entry.name.endsWith(shouldEndWith) === false) return;
+        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/restura.ts
-import bodyParser from "body-parser";
-import compression from "compression";
-import cookieParser from "cookie-parser";
-import { createHash } from "crypto";
-import * as express from "express";
-import fs4 from "fs";
-import path4 from "path";
-import pg3 from "pg";
-import * as prettier3 from "prettier";
+// src/restura/generators/apiGenerator.ts
+import { ObjectUtils, StringUtils } from "@redskytech/core-utils";
+import prettier from "prettier";
 
 // src/restura/sql/SqlUtils.ts
 var SqlUtils = class _SqlUtils {
@@ -250,7 +516,7 @@ var SqlUtils = class _SqlUtils {
   }
 };
 
-// src/restura/ResponseValidator.ts
+// src/restura/validators/ResponseValidator.ts
 var ResponseValidator = class _ResponseValidator {
   constructor(schema) {
     this.database = schema.database;
@@ -399,9 +665,7 @@ var ResponseValidator = class _ResponseValidator {
   }
 };
 
-// src/restura/apiGenerator.ts
-import { ObjectUtils, StringUtils } from "@redskytech/core-utils";
-import prettier from "prettier";
+// src/restura/generators/apiGenerator.ts
 var ApiTree = class _ApiTree {
   constructor(namespace, database) {
     this.database = database;
@@ -554,102 +818,43 @@ var ApiTree = class _ApiTree {
 function pathToNamespaces(path5) {
   return path5.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 **/`;
+function apiGenerator(schema) {
+  let apiString = `/** Auto generated file. DO NOT MODIFY **/
+`;
   const rootNamespace = ApiTree.createRootNode(schema.database);
   for (const endpoint of schema.endpoints) {
     const endpointNamespaces = pathToNamespaces(endpoint.baseUrl);
     rootNamespace.addData(endpointNamespaces, endpoint);
     for (const route of endpoint.routes) {
-      const fullNamespace = [...endpointNamespaces, ...pathToNamespaces(route.path)];
-      rootNamespace.addData(fullNamespace, route);
-    }
-  }
-  apiString += rootNamespace.createApiModels();
-  if (schema.customTypes.length > 0) {
-    apiString += `
-
-		declare namespace CustomTypes {
-			${schema.customTypes}
-		}`;
-  }
-  return prettier.format(apiString, __spreadValues({
-    parser: "typescript"
-  }, {
-    trailingComma: "none",
-    tabWidth: 4,
-    useTabs: true,
-    endOfLine: "lf",
-    printWidth: 120,
-    singleQuote: true
-  }));
-}
-
-// src/restura/customApiFactory.ts
-import fs from "fs";
-import path from "path";
-import Bluebird from "bluebird";
-import { fileUtils } from "@restura/internal";
-var CustomApiFactory = class {
-  constructor() {
-    this.customApis = {};
-  }
-  async loadApiFiles(baseFolderPath) {
-    const apiVersions = ["v1"];
-    for (const apiVersion of apiVersions) {
-      const apiVersionFolderPath = path.join(baseFolderPath, apiVersion);
-      const directoryExists = await fileUtils.existDir(apiVersionFolderPath);
-      if (!directoryExists) continue;
-      await this.addDirectory(apiVersionFolderPath, apiVersion);
-    }
-  }
-  getCustomApi(customApiName) {
-    return this.customApis[customApiName];
-  }
-  async addDirectory(directoryPath, apiVersion) {
-    var _a2;
-    const entries = await fs.promises.readdir(directoryPath, {
-      withFileTypes: true
-    });
-    const isTsx2 = (_a2 = process.argv[1]) == null ? void 0 : _a2.endsWith(".ts");
-    const isTsNode2 = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
-    const extension = isTsx2 || isTsNode2 ? "ts" : "js";
-    const shouldEndWith = `.api.${apiVersion}.${extension}`;
-    await Bluebird.map(entries, async (entry) => {
-      if (entry.isFile()) {
-        if (entry.name.endsWith(shouldEndWith) === false) return;
-        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);
-        }
-      }
-    });
+      const fullNamespace = [...endpointNamespaces, ...pathToNamespaces(route.path)];
+      rootNamespace.addData(fullNamespace, route);
+    }
   }
-  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);
-      }
-    });
+  apiString += rootNamespace.createApiModels();
+  if (schema.customTypes.length > 0) {
+    apiString += `
+
+		declare namespace CustomTypes {
+			${schema.customTypes}
+		}`;
   }
-};
-var customApiFactory = new CustomApiFactory();
-var customApiFactory_default = customApiFactory;
+  return prettier.format(apiString, __spreadValues({
+    parser: "typescript"
+  }, {
+    trailingComma: "none",
+    tabWidth: 4,
+    useTabs: true,
+    endOfLine: "lf",
+    printWidth: 120,
+    singleQuote: true
+  }));
+}
 
-// src/restura/customTypeValidationGenerator.ts
+// src/restura/generators/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";
+import * as TJS from "typescript-json-schema";
 function customTypeValidationGenerator(currentSchema) {
   const schemaObject = {};
   const customInterfaceNames = currentSchema.customTypes.match(new RegExp("(?<=interface\\s)(\\w+)|(?<=type\\s)(\\w+)", "g"));
@@ -659,13 +864,14 @@ function customTypeValidationGenerator(currentSchema) {
   const compilerOptions = {
     strictNullChecks: true,
     skipLibCheck: true
+    // Needed if we are processing ES modules
   };
   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")
+      path2.join(restura.resturaConfig.generatedTypesPath, "restura.d.ts"),
+      path2.join(restura.resturaConfig.generatedTypesPath, "models.d.ts"),
+      path2.join(restura.resturaConfig.generatedTypesPath, "api.d.ts")
     ],
     compilerOptions
   );
@@ -679,6 +885,61 @@ function customTypeValidationGenerator(currentSchema) {
   return schemaObject;
 }
 
+// src/restura/generators/modelGenerator.ts
+import { StringUtils as StringUtils2 } from "@redskytech/core-utils";
+import prettier2 from "prettier";
+function modelGenerator(schema) {
+  let modelString = `/** Auto generated file. DO NOT MODIFY **/
+
+`;
+  modelString += `declare namespace Model {
+`;
+  for (const table of schema.database) {
+    modelString += convertTable(table);
+  }
+  modelString += `}`;
+  return prettier2.format(modelString, __spreadValues({
+    parser: "typescript"
+  }, {
+    trailingComma: "none",
+    tabWidth: 4,
+    useTabs: true,
+    endOfLine: "lf",
+    printWidth: 120,
+    singleQuote: true
+  }));
+}
+function convertTable(table) {
+  let modelString = `	export interface ${StringUtils2.capitalizeFirst(table.name)} {
+`;
+  for (const column of table.columns) {
+    modelString += `		${column.name}${column.isNullable ? "?" : ""}: ${SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value)};
+`;
+  }
+  modelString += `	}
+`;
+  return modelString;
+}
+
+// src/restura/generators/resturaGlobalTypesGenerator.ts
+function resturaGlobalTypesGenerator() {
+  return `/** Auto generated file. DO NOT MODIFY **/
+/** This file contains types that may be used in the CustomTypes of Restura **/
+/** For example export interface MyPagedQuery extends Restura.PageQuery { } **/
+	
+declare namespace Restura {
+	export type StandardOrderTypes = 'ASC' | 'DESC' | 'RAND' | 'NONE';
+	export interface PageQuery {
+		page?: number;
+		perPage?: number;
+		sortBy?: string;
+		sortOrder?: StandardOrderTypes;
+		filter?: string;
+	}
+}
+`;
+}
+
 // src/restura/middleware/addApiResponseFunctions.ts
 function addApiResponseFunctions(req, res, next) {
   res.sendData = function(data, statusCode = 200) {
@@ -717,10 +978,35 @@ function authenticateUser(applicationAuthenticateHandler) {
   };
 }
 
-// src/restura/restura.schema.ts
+// src/restura/middleware/getMulterUpload.ts
+import multer from "multer";
+import * as os from "os";
+import { extname } from "path";
+var OneHundredMB = 100 * 1024 * 1024;
+var commonUpload = null;
+var getMulterUpload = (directory) => {
+  if (commonUpload) return commonUpload;
+  const storage = multer.diskStorage({
+    destination: directory || os.tmpdir(),
+    filename: function(request, file, cb) {
+      const extension = extname(file.originalname);
+      const uniqueName = Date.now() + "-" + Math.round(Math.random() * 1e3);
+      cb(null, `${uniqueName}${extension}`);
+    }
+  });
+  commonUpload = multer({
+    storage,
+    limits: {
+      fileSize: OneHundredMB
+    }
+  });
+  return commonUpload;
+};
+
+// src/restura/schemas/resturaSchema.ts
 import { z as z3 } from "zod";
 
-// src/restura/types/validation.types.ts
+// src/restura/schemas/validatorDataSchema.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({
@@ -728,7 +1014,7 @@ var validatorDataSchema = z2.object({
   value: validatorDataSchemeValue
 }).strict();
 
-// src/restura/restura.schema.ts
+// src/restura/schemas/resturaSchema.ts
 var orderBySchema = z3.object({
   columnName: z3.string(),
   order: z3.enum(["ASC", "DESC"]),
@@ -975,7 +1261,7 @@ var endpointDataSchema = z3.object({
   baseUrl: z3.string(),
   routes: z3.array(z3.union([standardRouteSchema, customRouteSchema]))
 }).strict();
-var resturaZodSchema = z3.object({
+var resturaSchema = z3.object({
   database: z3.array(tableDataSchema),
   endpoints: z3.array(endpointDataSchema),
   globalParams: z3.array(z3.string()),
@@ -984,7 +1270,7 @@ var resturaZodSchema = z3.object({
 }).strict();
 async function isSchemaValid(schemaToCheck) {
   try {
-    resturaZodSchema.parse(schemaToCheck);
+    resturaSchema.parse(schemaToCheck);
     return true;
   } catch (error) {
     logger.error(error);
@@ -992,7 +1278,7 @@ async function isSchemaValid(schemaToCheck) {
   }
 }
 
-// src/restura/validateRequestParams.ts
+// src/restura/validators/requestValidator.ts
 import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
 import jsonschema from "jsonschema";
 import { z as z4 } from "zod";
@@ -1009,8 +1295,8 @@ function addQuotesToStrings(variable) {
   }
 }
 
-// src/restura/validateRequestParams.ts
-function validateRequestParams(req, routeData, validationSchema) {
+// src/restura/validators/requestValidator.ts
+function requestValidator(req, routeData, validationSchema) {
   const requestData = getRequestData(req);
   req.data = requestData;
   if (routeData.request === void 0) {
@@ -1125,239 +1411,93 @@ function performMinCheck(requestValue, validator, requestParamName) {
 }
 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) {
-  req.data = getRequestData(req);
-  try {
-    resturaZodSchema.parse(req.data);
-    next();
-  } catch (error) {
-    logger.error(error);
-    res.sendError("BAD_REQUEST", error, 400 /* BAD_REQUEST */);
-  }
-}
-
-// src/restura/modelGenerator.ts
-import { StringUtils as StringUtils2 } from "@redskytech/core-utils";
-import prettier2 from "prettier";
-function modelGenerator(schema, schemaHash) {
-  let modelString = `/** Auto generated file from Schema Hash (${schemaHash}). DO NOT MODIFY **/
-`;
-  modelString += `declare namespace Model {
-`;
-  for (const table of schema.database) {
-    modelString += convertTable(table);
-  }
-  modelString += `}`;
-  return prettier2.format(modelString, __spreadValues({
-    parser: "typescript"
-  }, {
-    trailingComma: "none",
-    tabWidth: 4,
-    useTabs: true,
-    endOfLine: "lf",
-    printWidth: 120,
-    singleQuote: true
-  }));
-}
-function convertTable(table) {
-  let modelString = `	export interface ${StringUtils2.capitalizeFirst(table.name)} {
-`;
-  for (const column of table.columns) {
-    modelString += `		${column.name}${column.isNullable ? "?" : ""}: ${SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value)};
-`;
-  }
-  modelString += `	}
-`;
-  return modelString;
-}
-
-// src/restura/sql/PsqlEngine.ts
-import { ObjectUtils as ObjectUtils4 } from "@redskytech/core-utils";
-import getDiff from "@wmfs/pg-diff-sync";
-import pgInfo from "@wmfs/pg-info";
-import pg2 from "pg";
-
-// src/restura/eventManager.ts
-import Bluebird2 from "bluebird";
-var EventManager = class {
-  constructor() {
-    this.actionHandlers = {
-      DATABASE_ROW_DELETE: [],
-      DATABASE_ROW_INSERT: [],
-      DATABASE_COLUMN_UPDATE: []
-    };
-  }
-  addRowInsertHandler(onInsert, filter) {
-    this.actionHandlers.DATABASE_ROW_INSERT.push({
-      callback: onInsert,
-      filter
-    });
-  }
-  addColumnChangeHandler(onUpdate, filter) {
-    this.actionHandlers.DATABASE_COLUMN_UPDATE.push({
-      callback: onUpdate,
-      filter
-    });
-  }
-  addRowDeleteHandler(onDelete, filter) {
-    this.actionHandlers.DATABASE_ROW_DELETE.push({
-      callback: onDelete,
-      filter
-    });
-  }
-  async fireActionFromDbTrigger(sqlMutationData, result) {
-    if (sqlMutationData.mutationType === "INSERT") {
-      await this.fireInsertActions(sqlMutationData, result);
-    } else if (sqlMutationData.mutationType === "UPDATE") {
-      await this.fireUpdateActions(sqlMutationData, result);
-    } else if (sqlMutationData.mutationType === "DELETE") {
-      await this.fireDeleteActions(sqlMutationData, result);
-    }
-  }
-  async fireInsertActions(data, triggerResult) {
-    await Bluebird2.map(
-      this.actionHandlers.DATABASE_ROW_INSERT,
-      ({ callback, filter }) => {
-        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
-        const insertData = {
-          tableName: triggerResult.table,
-          insertId: triggerResult.record.id,
-          insertObject: triggerResult.record,
-          queryMetadata: data.queryMetadata
-        };
-        callback(insertData, data.queryMetadata);
-      },
-      { concurrency: 10 }
-    );
-  }
-  async fireDeleteActions(data, triggerResult) {
-    await Bluebird2.map(
-      this.actionHandlers.DATABASE_ROW_DELETE,
-      ({ callback, filter }) => {
-        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
-        const deleteData = {
-          tableName: triggerResult.table,
-          deletedRow: triggerResult.previousRecord,
-          queryMetadata: data.queryMetadata
-        };
-        callback(deleteData, data.queryMetadata);
-      },
-      { concurrency: 10 }
+  if (requestValue > validator.value)
+    throw new RsError(
+      "BAD_REQUEST",
+      `Request param (${requestParamName}) with value (${requestValue}) is more than (${validator.value})`
     );
-  }
-  async fireUpdateActions(data, triggerResult) {
-    await Bluebird2.map(
-      this.actionHandlers.DATABASE_COLUMN_UPDATE,
-      ({ callback, filter }) => {
-        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
-        const columnChangeData = {
-          tableName: triggerResult.table,
-          rowId: triggerResult.record.id,
-          newData: triggerResult.record,
-          oldData: triggerResult.previousRecord,
-          queryMetadata: data.queryMetadata
-        };
-        callback(columnChangeData, data.queryMetadata);
-      },
-      { concurrency: 10 }
+}
+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";
   }
-  hasHandlersForEventType(eventType, filter, triggerResult) {
-    if (filter) {
-      switch (eventType) {
-        case "DATABASE_ROW_INSERT":
-        case "DATABASE_ROW_DELETE":
-          if (filter.tableName && filter.tableName !== triggerResult.table) return false;
-          break;
-        case "DATABASE_COLUMN_UPDATE":
-          const filterColumnChange = filter;
-          if (filterColumnChange.tableName !== filter.tableName) return false;
-          if (!filterColumnChange.columns.some((item) => {
-            const updatedColumns = Object.keys(
-              changedValues(triggerResult.record, triggerResult.previousRecord)
-            );
-            return updatedColumns.includes(item);
-          }))
-            return false;
-          break;
-      }
-    }
-    return true;
-  }
-};
-var eventManager = new EventManager();
-var eventManager_default = eventManager;
-function changedValues(record, previousRecord) {
-  const changed = {};
-  for (const i in previousRecord) {
-    if (previousRecord[i] !== record[i]) {
-      if (typeof previousRecord[i] === "object" && typeof record[i] === "object") {
-        const nestedChanged = changedValues(record[i], previousRecord[i]);
-        if (Object.keys(nestedChanged).length > 0) {
-          changed[i] = record[i];
+  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 {
-        changed[i] = record[i];
+        bodyData[attr] = ObjectUtils2.safeParse(bodyData[attr]);
+        if (isNaN(Number(bodyData[attr]))) continue;
+        bodyData[attr] = Number(bodyData[attr]);
       }
     }
   }
-  return changed;
+  return bodyData;
+}
+
+// src/restura/middleware/schemaValidation.ts
+async function schemaValidation(req, res, next) {
+  req.data = getRequestData(req);
+  try {
+    resturaSchema.parse(req.data);
+    next();
+  } catch (error) {
+    logger.error(error);
+    res.sendError("BAD_REQUEST", error, 400 /* BAD_REQUEST */);
+  }
 }
 
+// src/restura/schemas/resturaConfigSchema.ts
+import { z as z5 } from "zod";
+var _a;
+var isTsx = (_a = process.argv[1]) == null ? void 0 : _a.endsWith(".ts");
+var isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
+var customApiFolderPath = isTsx || isTsNode ? "/src/api" : "/dist/api";
+var resturaConfigSchema = z5.object({
+  authToken: z5.string().min(1, "Missing Restura Auth Token"),
+  sendErrorStackTrace: z5.boolean().default(false),
+  schemaFilePath: z5.string().default(process.cwd() + "/restura.schema.json"),
+  customApiFolderPath: z5.string().default(process.cwd() + customApiFolderPath),
+  generatedTypesPath: z5.string().default(process.cwd() + "/src/@types"),
+  fileTempCachePath: z5.string().optional()
+});
+
+// src/restura/sql/PsqlEngine.ts
+import { ObjectUtils as ObjectUtils4 } from "@redskytech/core-utils";
+import getDiff from "@wmfs/pg-diff-sync";
+import pgInfo from "@wmfs/pg-info";
+import pg2 from "pg";
+
 // src/restura/sql/PsqlPool.ts
 import pg from "pg";
 
 // src/restura/sql/PsqlConnection.ts
+import crypto from "crypto";
 import format3 from "pg-format";
 
 // src/restura/sql/PsqlUtils.ts
@@ -1410,7 +1550,6 @@ function SQL(strings, ...values) {
 }
 
 // src/restura/sql/PsqlConnection.ts
-import crypto from "crypto";
 var PsqlConnection = class {
   constructor() {
     this.instanceId = crypto.randomUUID();
@@ -2262,121 +2401,6 @@ function schemaToPsqlType(column) {
   return column.type;
 }
 
-// src/restura/compareSchema.ts
-import cloneDeep from "lodash.clonedeep";
-var CompareSchema = class {
-  async diffSchema(newSchema, latestSchema, psqlEngine) {
-    const endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
-    const globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
-    const roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
-    let commands = "";
-    if (JSON.stringify(newSchema.database) !== JSON.stringify(latestSchema.database))
-      commands = await psqlEngine.diffDatabaseToSchema(newSchema);
-    const customTypes = newSchema.customTypes !== latestSchema.customTypes;
-    const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
-    return schemaPreview;
-  }
-  diffStringArray(newArray, originalArray) {
-    const stringsDiff = [];
-    const originalClone = new Set(originalArray);
-    newArray.forEach((item) => {
-      const originalIndex = originalClone.has(item);
-      if (!originalIndex) {
-        stringsDiff.push({
-          name: item,
-          changeType: "NEW"
-        });
-      } else {
-        originalClone.delete(item);
-      }
-    });
-    originalClone.forEach((item) => {
-      stringsDiff.push({
-        name: item,
-        changeType: "DELETED"
-      });
-    });
-    return stringsDiff;
-  }
-  diffEndPoints(newEndPoints, originalEndpoints) {
-    const originalClone = cloneDeep(originalEndpoints);
-    const diffObj = [];
-    newEndPoints.forEach((endPoint) => {
-      const { path: path5, method } = endPoint;
-      const endPointIndex = originalClone.findIndex((original) => {
-        return original.path === endPoint.path && original.method === endPoint.method;
-      });
-      if (endPointIndex === -1) {
-        diffObj.push({
-          name: `${method} ${path5}`,
-          changeType: "NEW"
-        });
-      } else {
-        const original = originalClone.findIndex((original2) => {
-          return this.compareEndPoints(endPoint, original2);
-        });
-        if (original === -1) {
-          diffObj.push({
-            name: `${method} ${path5}`,
-            changeType: "MODIFIED"
-          });
-        }
-        originalClone.splice(endPointIndex, 1);
-      }
-    });
-    originalClone.forEach((original) => {
-      const { path: path5, method } = original;
-      diffObj.push({
-        name: `${method} ${path5}`,
-        changeType: "DELETED"
-      });
-    });
-    return diffObj;
-  }
-  compareEndPoints(endPoint1, endPoint2) {
-    return JSON.stringify(endPoint1) === JSON.stringify(endPoint2);
-  }
-};
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "diffSchema", 1);
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "diffStringArray", 1);
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "diffEndPoints", 1);
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "compareEndPoints", 1);
-var compareSchema = new CompareSchema();
-var compareSchema_default = compareSchema;
-
-// src/restura/middleware/getMulterUploadSingleton.ts
-import multer from "multer";
-import { extname } from "path";
-import * as os from "os";
-var OneHundredMB = 100 * 1024 * 1024;
-var commonUpload = null;
-var getMulterUploadSingleton = (directory) => {
-  if (commonUpload) return commonUpload;
-  const storage = multer.diskStorage({
-    destination: directory || os.tmpdir(),
-    filename: function(request, file, cb) {
-      const extension = extname(file.originalname);
-      const uniqueName = Date.now() + "-" + Math.round(Math.random() * 1e3);
-      cb(null, `${uniqueName}${extension}`);
-    }
-  });
-  commonUpload = multer({
-    storage,
-    limits: {
-      fileSize: OneHundredMB
-    }
-  });
-  return commonUpload;
-};
-
 // src/restura/utils/TempCache.ts
 import fs3 from "fs";
 import path3 from "path";
@@ -2429,7 +2453,7 @@ var ResturaEngine = class {
    */
   async init(app, authenticationHandler, psqlConnectionPool) {
     this.resturaConfig = config2.validate("restura", resturaConfigSchema);
-    this.multerCommonUpload = getMulterUploadSingleton(this.resturaConfig.fileTempCachePath);
+    this.multerCommonUpload = getMulterUpload(this.resturaConfig.fileTempCachePath);
     new TempCache(this.resturaConfig.fileTempCachePath);
     this.psqlConnectionPool = psqlConnectionPool;
     this.psqlEngine = new PsqlEngine(this.psqlConnectionPool, true);
@@ -2497,10 +2521,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) {
-    fs4.writeFileSync(
-      outputFile,
-      await apiGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
-    );
+    fs4.writeFileSync(outputFile, await apiGenerator(providedSchema));
   }
   /**
    * Generates a model from the provided schema and writes it to the specified output file.
@@ -2510,10 +2531,15 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the model has been successfully written to the output file.
    */
   async generateModelFromSchema(outputFile, providedSchema) {
-    fs4.writeFileSync(
-      outputFile,
-      await modelGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
-    );
+    fs4.writeFileSync(outputFile, await modelGenerator(providedSchema));
+  }
+  /**
+   * Generates the ambient module declaration for Restura global types and writes it to the specified output file.
+   * These types are used sometimes in the CustomTypes
+   * @param outputFile
+   */
+  generateResturaGlobalTypes(outputFile) {
+    fs4.writeFileSync(outputFile, resturaGlobalTypesGenerator());
   }
   /**
    * Retrieves the latest file system schema for Restura.
@@ -2535,28 +2561,6 @@ var ResturaEngine = class {
     }
     return schema;
   }
-  /**
-   * Asynchronously generates and retrieves hashes for the provided schema and related generated files.
-   *
-   * @param providedSchema - The schema for which hashes need to be generated.
-   * @returns A promise that resolves to an object containing:
-   * - `schemaHash`: The hash of the provided schema.
-   * - `apiCreatedSchemaHash`: The hash extracted from the generated `api.d.ts` file.
-   * - `modelCreatedSchemaHash`: The hash extracted from the generated `models.d.ts` file.
-   */
-  async getHashes(providedSchema) {
-    var _a2, _b, _c, _d;
-    const schemaHash = await this.generateHashForSchema(providedSchema);
-    const apiFile = fs4.readFileSync(path4.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const apiCreatedSchemaHash = (_b = (_a2 = apiFile.toString().match(/\((.*)\)/)) == null ? void 0 : _a2[1]) != null ? _b : "";
-    const modelFile = fs4.readFileSync(path4.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
-    const modelCreatedSchemaHash = (_d = (_c = modelFile.toString().match(/\((.*)\)/)) == null ? void 0 : _c[1]) != null ? _d : "";
-    return {
-      schemaHash,
-      apiCreatedSchemaHash,
-      modelCreatedSchemaHash
-    };
-  }
   async reloadEndpoints() {
     this.schema = await this.getLatestFileSystemSchema();
     this.customTypeValidation = customTypeValidationGenerator(this.schema);
@@ -2588,27 +2592,7 @@ var ResturaEngine = class {
     if (!fs4.existsSync(this.resturaConfig.generatedTypesPath)) {
       fs4.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
     }
-    const hasApiFile = fs4.existsSync(path4.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const hasModelsFile = fs4.existsSync(path4.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
-    if (!hasApiFile) {
-      await this.generateApiFromSchema(path4.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
-    }
-    if (!hasModelsFile) {
-      await this.generateModelFromSchema(
-        path4.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
-        this.schema
-      );
-    }
-    const hashes = await this.getHashes(this.schema);
-    if (hashes.schemaHash !== hashes.apiCreatedSchemaHash) {
-      await this.generateApiFromSchema(path4.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
-    }
-    if (hashes.schemaHash !== hashes.modelCreatedSchemaHash) {
-      await this.generateModelFromSchema(
-        path4.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
-        this.schema
-      );
-    }
+    this.updateTypes();
   }
   resturaAuthentication(req, res, next) {
     if (req.headers["x-auth-token"] !== this.resturaConfig.authToken) res.status(401).send("Unauthorized");
@@ -2640,6 +2624,7 @@ var ResturaEngine = class {
       path4.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
       this.schema
     );
+    this.generateResturaGlobalTypes(path4.join(this.resturaConfig.generatedTypesPath, "restura.d.ts"));
   }
   async getSchema(req, res) {
     res.send({ data: this.schema });
@@ -2647,9 +2632,8 @@ var ResturaEngine = class {
   async getSchemaAndTypes(req, res) {
     try {
       const schema = await this.getLatestFileSystemSchema();
-      const schemaHash = await this.generateHashForSchema(schema);
-      const apiText = await apiGenerator(schema, schemaHash);
-      const modelsText = await modelGenerator(schema, schemaHash);
+      const apiText = await apiGenerator(schema);
+      const modelsText = await modelGenerator(schema);
       res.send({ schema, api: apiText, models: modelsText });
     } catch (err) {
       res.status(400).send({ error: err });
@@ -2679,7 +2663,7 @@ var ResturaEngine = class {
       const routeData = this.getRouteData(req.method, req.baseUrl, req.path);
       this.validateAuthorization(req, routeData);
       await this.getMulterFilesIfAny(req, res, routeData);
-      validateRequestParams(req, routeData, this.customTypeValidation);
+      requestValidator(req, routeData, this.customTypeValidation);
       if (this.isCustomRoute(routeData)) {
         await this.runCustomRouteLogic(req, res, routeData);
         return;
@@ -2719,19 +2703,6 @@ var ResturaEngine = class {
       throw new RsError("NOT_FOUND", `API path ${routeData.path} not implemented ${functionName}`);
     await customFunction(req, res, routeData);
   }
-  async generateHashForSchema(providedSchema) {
-    const schemaPrettyStr = await prettier3.format(JSON.stringify(providedSchema), __spreadValues({
-      parser: "json"
-    }, {
-      trailingComma: "none",
-      tabWidth: 4,
-      useTabs: true,
-      endOfLine: "lf",
-      printWidth: 120,
-      singleQuote: true
-    }));
-    return createHash("sha256").update(schemaPrettyStr).digest("hex");
-  }
   async storeFileSystemSchema() {
     const schemaPrettyStr = await prettier3.format(JSON.stringify(this.schema), __spreadValues({
       parser: "json"