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

package/dist/index.js

@@ -90,23 +90,11 @@ var import_internal = require("@restura/internal");
 var import_winston = __toESM(require("winston"));
 var import_logform = require("logform");
 
-// src/config.schema.ts
+// src/logger/loggerConfigSchema.ts
 var import_zod = require("zod");
 var loggerConfigSchema = import_zod.z.object({
   level: import_zod.z.enum(["info", "warn", "error", "debug", "silly"]).default("info")
 });
-var _a;
-var isTsx = (_a = process.argv[1]) == null ? void 0 : _a.endsWith(".ts");
-var isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
-var customApiFolderPath = isTsx || isTsNode ? "/src/api" : "/dist/api";
-var resturaConfigSchema = import_zod.z.object({
-  authToken: import_zod.z.string().min(1, "Missing Restura Auth Token"),
-  sendErrorStackTrace: import_zod.z.boolean().default(false),
-  schemaFilePath: import_zod.z.string().default(process.cwd() + "/restura.schema.json"),
-  customApiFolderPath: import_zod.z.string().default(process.cwd() + customApiFolderPath),
-  generatedTypesPath: import_zod.z.string().default(process.cwd() + "/src/@types"),
-  fileTempCachePath: import_zod.z.string().optional()
-});
 
 // src/logger/logger.ts
 var loggerConfig = import_internal.config.validate("logger", loggerConfigSchema);
@@ -143,7 +131,194 @@ var logger = import_winston.default.createLogger({
   ]
 });
 
-// src/restura/errors.ts
+// src/restura/eventManager.ts
+var import_bluebird = __toESM(require("bluebird"));
+var EventManager = class {
+  constructor() {
+    this.actionHandlers = {
+      DATABASE_ROW_DELETE: [],
+      DATABASE_ROW_INSERT: [],
+      DATABASE_COLUMN_UPDATE: []
+    };
+  }
+  addRowInsertHandler(onInsert, filter) {
+    this.actionHandlers.DATABASE_ROW_INSERT.push({
+      callback: onInsert,
+      filter
+    });
+  }
+  addColumnChangeHandler(onUpdate, filter) {
+    this.actionHandlers.DATABASE_COLUMN_UPDATE.push({
+      callback: onUpdate,
+      filter
+    });
+  }
+  addRowDeleteHandler(onDelete, filter) {
+    this.actionHandlers.DATABASE_ROW_DELETE.push({
+      callback: onDelete,
+      filter
+    });
+  }
+  async fireActionFromDbTrigger(sqlMutationData, result) {
+    if (sqlMutationData.mutationType === "INSERT") {
+      await this.fireInsertActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "UPDATE") {
+      await this.fireUpdateActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "DELETE") {
+      await this.fireDeleteActions(sqlMutationData, result);
+    }
+  }
+  async fireInsertActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_ROW_INSERT,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
+        const insertData = {
+          tableName: triggerResult.table,
+          insertId: triggerResult.record.id,
+          insertObject: triggerResult.record,
+          queryMetadata: data.queryMetadata
+        };
+        callback(insertData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireDeleteActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_ROW_DELETE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
+        const deleteData = {
+          tableName: triggerResult.table,
+          deletedRow: triggerResult.previousRecord,
+          queryMetadata: data.queryMetadata
+        };
+        callback(deleteData, data.queryMetadata);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireUpdateActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_COLUMN_UPDATE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
+        const columnChangeData = {
+          tableName: triggerResult.table,
+          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
+var import_core_utils7 = require("@redskytech/core-utils");
+var import_internal4 = require("@restura/internal");
+
+// ../../node_modules/.pnpm/autobind-decorator@2.4.0/node_modules/autobind-decorator/lib/esm/index.js
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+function boundMethod(target, key, descriptor) {
+  var fn = descriptor.value;
+  if (typeof fn !== "function") {
+    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
+  }
+  var definingProperty = false;
+  return {
+    configurable: true,
+    get: function get() {
+      if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== "function") {
+        return fn;
+      }
+      var boundFn = fn.bind(this);
+      definingProperty = true;
+      Object.defineProperty(this, key, {
+        configurable: true,
+        get: function get2() {
+          return boundFn;
+        },
+        set: function set(value) {
+          fn = value;
+          delete this[key];
+        }
+      });
+      definingProperty = false;
+      return boundFn;
+    },
+    set: function set(value) {
+      fn = value;
+    }
+  };
+}
+
+// src/restura/restura.ts
+var import_body_parser = __toESM(require("body-parser"));
+var import_compression = __toESM(require("compression"));
+var import_cookie_parser = __toESM(require("cookie-parser"));
+var express = __toESM(require("express"));
+var import_fs4 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_pg3 = __toESM(require("pg"));
+var prettier3 = __toESM(require("prettier"));
+
+// src/restura/RsError.ts
 var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
   HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
   HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
@@ -167,7 +342,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;
   }
@@ -209,66 +383,158 @@ var htmlStatusMap = {
   SCHEMA_ERROR: 500 /* SERVER_ERROR */
 };
 
-// src/restura/restura.ts
-var import_core_utils7 = require("@redskytech/core-utils");
-var import_internal4 = require("@restura/internal");
-
-// ../../node_modules/.pnpm/autobind-decorator@2.4.0/node_modules/autobind-decorator/lib/esm/index.js
-function _typeof(obj) {
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function _typeof2(obj2) {
-      return typeof obj2;
-    };
-  } else {
-    _typeof = function _typeof2(obj2) {
-      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    };
-  }
-  return _typeof(obj);
-}
-function boundMethod(target, key, descriptor) {
-  var fn = descriptor.value;
-  if (typeof fn !== "function") {
-    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
+// src/restura/compareSchema.ts
+var import_lodash = __toESM(require("lodash.clonedeep"));
+var CompareSchema = class {
+  async diffSchema(newSchema, latestSchema, psqlEngine) {
+    const endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
+    const globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
+    const roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
+    let commands = "";
+    if (JSON.stringify(newSchema.database) !== JSON.stringify(latestSchema.database))
+      commands = await psqlEngine.diffDatabaseToSchema(newSchema);
+    const customTypes = newSchema.customTypes !== latestSchema.customTypes;
+    const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
+    return schemaPreview;
   }
-  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 = (0, import_lodash.default)(originalEndpoints);
+    const diffObj = [];
+    newEndPoints.forEach((endPoint) => {
+      const { path: path5, method } = endPoint;
+      const endPointIndex = originalClone.findIndex((original) => {
+        return original.path === endPoint.path && original.method === endPoint.method;
+      });
+      if (endPointIndex === -1) {
+        diffObj.push({
+          name: `${method} ${path5}`,
+          changeType: "NEW"
+        });
+      } else {
+        const original = originalClone.findIndex((original2) => {
+          return this.compareEndPoints(endPoint, original2);
+        });
+        if (original === -1) {
+          diffObj.push({
+            name: `${method} ${path5}`,
+            changeType: "MODIFIED"
+          });
         }
+        originalClone.splice(endPointIndex, 1);
+      }
+    });
+    originalClone.forEach((original) => {
+      const { path: path5, method } = original;
+      diffObj.push({
+        name: `${method} ${path5}`,
+        changeType: "DELETED"
       });
-      definingProperty = false;
-      return boundFn;
-    },
-    set: function set(value) {
-      fn = value;
+    });
+    return diffObj;
+  }
+  compareEndPoints(endPoint1, endPoint2) {
+    return JSON.stringify(endPoint1) === JSON.stringify(endPoint2);
+  }
+};
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffSchema", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffStringArray", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffEndPoints", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "compareEndPoints", 1);
+var compareSchema = new CompareSchema();
+var compareSchema_default = compareSchema;
+
+// src/restura/customApiFactory.ts
+var import_internal2 = require("@restura/internal");
+var import_bluebird2 = __toESM(require("bluebird"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var CustomApiFactory = class {
+  constructor() {
+    this.customApis = {};
+  }
+  async loadApiFiles(baseFolderPath) {
+    const apiVersions = ["v1"];
+    for (const apiVersion of apiVersions) {
+      const apiVersionFolderPath = import_path.default.join(baseFolderPath, apiVersion);
+      const directoryExists = await import_internal2.fileUtils.existDir(apiVersionFolderPath);
+      if (!directoryExists) continue;
+      await this.addDirectory(apiVersionFolderPath, apiVersion);
     }
-  };
-}
+  }
+  getCustomApi(customApiName) {
+    return this.customApis[customApiName];
+  }
+  async addDirectory(directoryPath, apiVersion) {
+    var _a2;
+    const entries = await import_fs.default.promises.readdir(directoryPath, {
+      withFileTypes: true
+    });
+    const isTsx2 = (_a2 = process.argv[1]) == null ? void 0 : _a2.endsWith(".ts");
+    const isTsNode2 = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
+    const extension = isTsx2 || isTsNode2 ? "ts" : "js";
+    const shouldEndWith = `.api.${apiVersion}.${extension}`;
+    await import_bluebird2.default.map(entries, async (entry) => {
+      if (entry.isFile()) {
+        if (entry.name.endsWith(shouldEndWith) === false) return;
+        try {
+          const importPath = `${import_path.default.join(directoryPath, entry.name)}`;
+          const ApiImport = await import(importPath);
+          const customApiClass = new ApiImport.default();
+          logger.info(`Registering custom API: ${ApiImport.default.name}`);
+          this.bindMethodsToInstance(customApiClass);
+          this.customApis[ApiImport.default.name] = customApiClass;
+        } catch (e) {
+          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
-var import_body_parser = __toESM(require("body-parser"));
-var import_compression = __toESM(require("compression"));
-var import_cookie_parser = __toESM(require("cookie-parser"));
-var import_crypto2 = require("crypto");
-var express = __toESM(require("express"));
-var import_fs4 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
-var import_pg3 = __toESM(require("pg"));
-var prettier3 = __toESM(require("prettier"));
+// src/restura/generators/apiGenerator.ts
+var import_core_utils = require("@redskytech/core-utils");
+var import_prettier = __toESM(require("prettier"));
 
 // src/restura/sql/SqlUtils.ts
 var SqlUtils = class _SqlUtils {
@@ -296,7 +562,7 @@ var SqlUtils = class _SqlUtils {
   }
 };
 
-// src/restura/ResponseValidator.ts
+// src/restura/validators/ResponseValidator.ts
 var ResponseValidator = class _ResponseValidator {
   constructor(schema) {
     this.database = schema.database;
@@ -445,9 +711,7 @@ var ResponseValidator = class _ResponseValidator {
   }
 };
 
-// src/restura/apiGenerator.ts
-var import_core_utils = require("@redskytech/core-utils");
-var import_prettier = __toESM(require("prettier"));
+// src/restura/generators/apiGenerator.ts
 var ApiTree = class _ApiTree {
   constructor(namespace, database) {
     this.database = database;
@@ -600,102 +864,43 @@ var ApiTree = class _ApiTree {
 function pathToNamespaces(path5) {
   return path5.split("/").map((e) => import_core_utils.StringUtils.toPascalCasing(e)).filter((e) => e);
 }
-function apiGenerator(schema, schemaHash) {
-  let apiString = `/** Auto generated file from Schema Hash (${schemaHash}). DO NOT MODIFY **/`;
+function apiGenerator(schema) {
+  let apiString = `/** Auto generated file. DO NOT MODIFY **/
+`;
   const rootNamespace = ApiTree.createRootNode(schema.database);
   for (const endpoint of schema.endpoints) {
     const endpointNamespaces = pathToNamespaces(endpoint.baseUrl);
     rootNamespace.addData(endpointNamespaces, endpoint);
     for (const route of endpoint.routes) {
-      const fullNamespace = [...endpointNamespaces, ...pathToNamespaces(route.path)];
-      rootNamespace.addData(fullNamespace, route);
-    }
-  }
-  apiString += rootNamespace.createApiModels();
-  if (schema.customTypes.length > 0) {
-    apiString += `
-
-		declare namespace CustomTypes {
-			${schema.customTypes}
-		}`;
-  }
-  return import_prettier.default.format(apiString, __spreadValues({
-    parser: "typescript"
-  }, {
-    trailingComma: "none",
-    tabWidth: 4,
-    useTabs: true,
-    endOfLine: "lf",
-    printWidth: 120,
-    singleQuote: true
-  }));
-}
-
-// src/restura/customApiFactory.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_bluebird = __toESM(require("bluebird"));
-var import_internal2 = require("@restura/internal");
-var CustomApiFactory = class {
-  constructor() {
-    this.customApis = {};
-  }
-  async loadApiFiles(baseFolderPath) {
-    const apiVersions = ["v1"];
-    for (const apiVersion of apiVersions) {
-      const apiVersionFolderPath = import_path.default.join(baseFolderPath, apiVersion);
-      const directoryExists = await import_internal2.fileUtils.existDir(apiVersionFolderPath);
-      if (!directoryExists) continue;
-      await this.addDirectory(apiVersionFolderPath, apiVersion);
-    }
-  }
-  getCustomApi(customApiName) {
-    return this.customApis[customApiName];
-  }
-  async addDirectory(directoryPath, apiVersion) {
-    var _a2;
-    const entries = await import_fs.default.promises.readdir(directoryPath, {
-      withFileTypes: true
-    });
-    const isTsx2 = (_a2 = process.argv[1]) == null ? void 0 : _a2.endsWith(".ts");
-    const isTsNode2 = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
-    const extension = isTsx2 || isTsNode2 ? "ts" : "js";
-    const shouldEndWith = `.api.${apiVersion}.${extension}`;
-    await import_bluebird.default.map(entries, async (entry) => {
-      if (entry.isFile()) {
-        if (entry.name.endsWith(shouldEndWith) === false) return;
-        try {
-          const importPath = `${import_path.default.join(directoryPath, entry.name)}`;
-          const ApiImport = await import(importPath);
-          const customApiClass = new ApiImport.default();
-          logger.info(`Registering custom API: ${ApiImport.default.name}`);
-          this.bindMethodsToInstance(customApiClass);
-          this.customApis[ApiImport.default.name] = customApiClass;
-        } catch (e) {
-          console.error(e);
-        }
-      }
-    });
+      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 import_prettier.default.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
 var import_fs2 = __toESM(require("fs"));
-var TJS = __toESM(require("typescript-json-schema"));
 var import_path2 = __toESM(require("path"));
 var import_tmp = __toESM(require("tmp"));
-var process2 = __toESM(require("process"));
+var TJS = __toESM(require("typescript-json-schema"));
 function customTypeValidationGenerator(currentSchema) {
   const schemaObject = {};
   const customInterfaceNames = currentSchema.customTypes.match(new RegExp("(?<=interface\\s)(\\w+)|(?<=type\\s)(\\w+)", "g"));
@@ -705,13 +910,14 @@ function customTypeValidationGenerator(currentSchema) {
   const compilerOptions = {
     strictNullChecks: true,
     skipLibCheck: true
+    // Needed if we are processing ES modules
   };
   const program = TJS.getProgramFromFiles(
     [
       (0, import_path2.resolve)(temporaryFile.name),
-      // find a way to remove
-      import_path2.default.join(process2.cwd(), "src/@types/models.d.ts"),
-      import_path2.default.join(process2.cwd(), "src/@types/api.d.ts")
+      import_path2.default.join(restura.resturaConfig.generatedTypesPath, "restura.d.ts"),
+      import_path2.default.join(restura.resturaConfig.generatedTypesPath, "models.d.ts"),
+      import_path2.default.join(restura.resturaConfig.generatedTypesPath, "api.d.ts")
     ],
     compilerOptions
   );
@@ -725,6 +931,61 @@ function customTypeValidationGenerator(currentSchema) {
   return schemaObject;
 }
 
+// src/restura/generators/modelGenerator.ts
+var import_core_utils2 = require("@redskytech/core-utils");
+var import_prettier2 = __toESM(require("prettier"));
+function modelGenerator(schema) {
+  let modelString = `/** Auto generated file. DO NOT MODIFY **/
+
+`;
+  modelString += `declare namespace Model {
+`;
+  for (const table of schema.database) {
+    modelString += convertTable(table);
+  }
+  modelString += `}`;
+  return import_prettier2.default.format(modelString, __spreadValues({
+    parser: "typescript"
+  }, {
+    trailingComma: "none",
+    tabWidth: 4,
+    useTabs: true,
+    endOfLine: "lf",
+    printWidth: 120,
+    singleQuote: true
+  }));
+}
+function convertTable(table) {
+  let modelString = `	export interface ${import_core_utils2.StringUtils.capitalizeFirst(table.name)} {
+`;
+  for (const column of table.columns) {
+    modelString += `		${column.name}${column.isNullable ? "?" : ""}: ${SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value)};
+`;
+  }
+  modelString += `	}
+`;
+  return modelString;
+}
+
+// src/restura/generators/resturaGlobalTypesGenerator.ts
+function resturaGlobalTypesGenerator() {
+  return `/** Auto generated file. DO NOT MODIFY **/
+/** This file contains types that may be used in the CustomTypes of Restura **/
+/** For example export interface MyPagedQuery extends Restura.PageQuery { } **/
+	
+declare namespace Restura {
+	export type StandardOrderTypes = 'ASC' | 'DESC' | 'RAND' | 'NONE';
+	export interface PageQuery {
+		page?: number;
+		perPage?: number;
+		sortBy?: string;
+		sortOrder?: StandardOrderTypes;
+		filter?: string;
+	}
+}
+`;
+}
+
 // src/restura/middleware/addApiResponseFunctions.ts
 function addApiResponseFunctions(req, res, next) {
   res.sendData = function(data, statusCode = 200) {
@@ -763,10 +1024,35 @@ function authenticateUser(applicationAuthenticateHandler) {
   };
 }
 
-// src/restura/restura.schema.ts
+// src/restura/middleware/getMulterUpload.ts
+var import_multer = __toESM(require("multer"));
+var os = __toESM(require("os"));
+var import_path3 = require("path");
+var OneHundredMB = 100 * 1024 * 1024;
+var commonUpload = null;
+var getMulterUpload = (directory) => {
+  if (commonUpload) return commonUpload;
+  const storage = import_multer.default.diskStorage({
+    destination: directory || os.tmpdir(),
+    filename: function(request, file, cb) {
+      const extension = (0, import_path3.extname)(file.originalname);
+      const uniqueName = Date.now() + "-" + Math.round(Math.random() * 1e3);
+      cb(null, `${uniqueName}${extension}`);
+    }
+  });
+  commonUpload = (0, import_multer.default)({
+    storage,
+    limits: {
+      fileSize: OneHundredMB
+    }
+  });
+  return commonUpload;
+};
+
+// src/restura/schemas/resturaSchema.ts
 var import_zod3 = require("zod");
 
-// src/restura/types/validation.types.ts
+// src/restura/schemas/validatorDataSchema.ts
 var import_zod2 = require("zod");
 var validatorDataSchemeValue = import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.string()), import_zod2.z.number(), import_zod2.z.array(import_zod2.z.number())]);
 var validatorDataSchema = import_zod2.z.object({
@@ -774,7 +1060,7 @@ var validatorDataSchema = import_zod2.z.object({
   value: validatorDataSchemeValue
 }).strict();
 
-// src/restura/restura.schema.ts
+// src/restura/schemas/resturaSchema.ts
 var orderBySchema = import_zod3.z.object({
   columnName: import_zod3.z.string(),
   order: import_zod3.z.enum(["ASC", "DESC"]),
@@ -1021,7 +1307,7 @@ var endpointDataSchema = import_zod3.z.object({
   baseUrl: import_zod3.z.string(),
   routes: import_zod3.z.array(import_zod3.z.union([standardRouteSchema, customRouteSchema]))
 }).strict();
-var resturaZodSchema = import_zod3.z.object({
+var resturaSchema = import_zod3.z.object({
   database: import_zod3.z.array(tableDataSchema),
   endpoints: import_zod3.z.array(endpointDataSchema),
   globalParams: import_zod3.z.array(import_zod3.z.string()),
@@ -1030,7 +1316,7 @@ var resturaZodSchema = import_zod3.z.object({
 }).strict();
 async function isSchemaValid(schemaToCheck) {
   try {
-    resturaZodSchema.parse(schemaToCheck);
+    resturaSchema.parse(schemaToCheck);
     return true;
   } catch (error) {
     logger.error(error);
@@ -1038,8 +1324,8 @@ async function isSchemaValid(schemaToCheck) {
   }
 }
 
-// src/restura/validateRequestParams.ts
-var import_core_utils2 = require("@redskytech/core-utils");
+// src/restura/validators/requestValidator.ts
+var import_core_utils3 = require("@redskytech/core-utils");
 var import_jsonschema = __toESM(require("jsonschema"));
 var import_zod4 = require("zod");
 
@@ -1055,8 +1341,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) {
@@ -1168,242 +1454,96 @@ function performMinCheck(requestValue, validator, requestParamName) {
       "BAD_REQUEST",
       `Request param (${requestParamName}) with value (${requestValue}) is less than (${validator.value})`
     );
-}
-function performMaxCheck(requestValue, validator, requestParamName) {
-  expectOnlyNumbers(requestValue, validator, requestParamName);
-  if (requestValue > validator.value)
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${requestValue}) is more than (${validator.value})`
-    );
-}
-function performOneOfCheck(requestValue, validator, requestParamName) {
-  if (!import_core_utils2.ObjectUtils.isArrayWithData(validator.value))
-    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value}) is not of type array`);
-  if (typeof requestValue === "object")
-    throw new RsError("BAD_REQUEST", `Request param (${requestParamName}) is not of type string or number`);
-  if (!validator.value.includes(requestValue))
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${requestValue}) is not one of (${validator.value.join(", ")})`
-    );
-}
-function isValueNumber(value) {
-  return !isNaN(Number(value));
-}
-function getRequestData(req) {
-  let body = "";
-  if (req.method === "GET" || req.method === "DELETE") {
-    body = "query";
-  } else {
-    body = "body";
-  }
-  const bodyData = req[body];
-  if (bodyData && body === "query") {
-    for (const attr in bodyData) {
-      if (bodyData[attr] instanceof Array) {
-        const attrList = [];
-        for (const value of bodyData[attr]) {
-          if (isNaN(Number(value))) continue;
-          attrList.push(Number(value));
-        }
-        if (import_core_utils2.ObjectUtils.isArrayWithData(attrList)) {
-          bodyData[attr] = attrList;
-        }
-      } else {
-        bodyData[attr] = import_core_utils2.ObjectUtils.safeParse(bodyData[attr]);
-        if (isNaN(Number(bodyData[attr]))) continue;
-        bodyData[attr] = Number(bodyData[attr]);
-      }
-    }
-  }
-  return bodyData;
-}
-
-// src/restura/middleware/schemaValidation.ts
-async function schemaValidation(req, res, next) {
-  req.data = getRequestData(req);
-  try {
-    resturaZodSchema.parse(req.data);
-    next();
-  } catch (error) {
-    logger.error(error);
-    res.sendError("BAD_REQUEST", error, 400 /* BAD_REQUEST */);
-  }
-}
-
-// src/restura/modelGenerator.ts
-var import_core_utils3 = require("@redskytech/core-utils");
-var import_prettier2 = __toESM(require("prettier"));
-function modelGenerator(schema, schemaHash) {
-  let modelString = `/** Auto generated file from Schema Hash (${schemaHash}). DO NOT MODIFY **/
-`;
-  modelString += `declare namespace Model {
-`;
-  for (const table of schema.database) {
-    modelString += convertTable(table);
-  }
-  modelString += `}`;
-  return import_prettier2.default.format(modelString, __spreadValues({
-    parser: "typescript"
-  }, {
-    trailingComma: "none",
-    tabWidth: 4,
-    useTabs: true,
-    endOfLine: "lf",
-    printWidth: 120,
-    singleQuote: true
-  }));
-}
-function convertTable(table) {
-  let modelString = `	export interface ${import_core_utils3.StringUtils.capitalizeFirst(table.name)} {
-`;
-  for (const column of table.columns) {
-    modelString += `		${column.name}${column.isNullable ? "?" : ""}: ${SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value)};
-`;
-  }
-  modelString += `	}
-`;
-  return modelString;
-}
-
-// src/restura/sql/PsqlEngine.ts
-var import_core_utils5 = require("@redskytech/core-utils");
-var import_pg_diff_sync = __toESM(require("@wmfs/pg-diff-sync"));
-var import_pg_info = __toESM(require("@wmfs/pg-info"));
-var import_pg2 = __toESM(require("pg"));
-
-// src/restura/eventManager.ts
-var import_bluebird2 = __toESM(require("bluebird"));
-var EventManager = class {
-  constructor() {
-    this.actionHandlers = {
-      DATABASE_ROW_DELETE: [],
-      DATABASE_ROW_INSERT: [],
-      DATABASE_COLUMN_UPDATE: []
-    };
-  }
-  addRowInsertHandler(onInsert, filter) {
-    this.actionHandlers.DATABASE_ROW_INSERT.push({
-      callback: onInsert,
-      filter
-    });
-  }
-  addColumnChangeHandler(onUpdate, filter) {
-    this.actionHandlers.DATABASE_COLUMN_UPDATE.push({
-      callback: onUpdate,
-      filter
-    });
-  }
-  addRowDeleteHandler(onDelete, filter) {
-    this.actionHandlers.DATABASE_ROW_DELETE.push({
-      callback: onDelete,
-      filter
-    });
-  }
-  async fireActionFromDbTrigger(sqlMutationData, result) {
-    if (sqlMutationData.mutationType === "INSERT") {
-      await this.fireInsertActions(sqlMutationData, result);
-    } else if (sqlMutationData.mutationType === "UPDATE") {
-      await this.fireUpdateActions(sqlMutationData, result);
-    } else if (sqlMutationData.mutationType === "DELETE") {
-      await this.fireDeleteActions(sqlMutationData, result);
-    }
-  }
-  async fireInsertActions(data, triggerResult) {
-    await import_bluebird2.default.map(
-      this.actionHandlers.DATABASE_ROW_INSERT,
-      ({ callback, filter }) => {
-        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
-        const insertData = {
-          tableName: triggerResult.table,
-          insertId: triggerResult.record.id,
-          insertObject: triggerResult.record,
-          queryMetadata: data.queryMetadata
-        };
-        callback(insertData, data.queryMetadata);
-      },
-      { concurrency: 10 }
-    );
-  }
-  async fireDeleteActions(data, triggerResult) {
-    await import_bluebird2.default.map(
-      this.actionHandlers.DATABASE_ROW_DELETE,
-      ({ callback, filter }) => {
-        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
-        const deleteData = {
-          tableName: triggerResult.table,
-          deletedRow: triggerResult.previousRecord,
-          queryMetadata: data.queryMetadata
-        };
-        callback(deleteData, data.queryMetadata);
-      },
-      { concurrency: 10 }
+}
+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})`
     );
-  }
-  async fireUpdateActions(data, triggerResult) {
-    await import_bluebird2.default.map(
-      this.actionHandlers.DATABASE_COLUMN_UPDATE,
-      ({ callback, filter }) => {
-        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
-        const columnChangeData = {
-          tableName: triggerResult.table,
-          rowId: triggerResult.record.id,
-          newData: triggerResult.record,
-          oldData: triggerResult.previousRecord,
-          queryMetadata: data.queryMetadata
-        };
-        callback(columnChangeData, data.queryMetadata);
-      },
-      { concurrency: 10 }
+}
+function performOneOfCheck(requestValue, validator, requestParamName) {
+  if (!import_core_utils3.ObjectUtils.isArrayWithData(validator.value))
+    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value}) is not of type array`);
+  if (typeof requestValue === "object")
+    throw new RsError("BAD_REQUEST", `Request param (${requestParamName}) is not of type string or number`);
+  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 (import_core_utils3.ObjectUtils.isArrayWithData(attrList)) {
+          bodyData[attr] = attrList;
         }
       } else {
-        changed[i] = record[i];
+        bodyData[attr] = import_core_utils3.ObjectUtils.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
+var import_zod5 = require("zod");
+var _a;
+var isTsx = (_a = process.argv[1]) == null ? void 0 : _a.endsWith(".ts");
+var isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT;
+var customApiFolderPath = isTsx || isTsNode ? "/src/api" : "/dist/api";
+var resturaConfigSchema = import_zod5.z.object({
+  authToken: import_zod5.z.string().min(1, "Missing Restura Auth Token"),
+  sendErrorStackTrace: import_zod5.z.boolean().default(false),
+  schemaFilePath: import_zod5.z.string().default(process.cwd() + "/restura.schema.json"),
+  customApiFolderPath: import_zod5.z.string().default(process.cwd() + customApiFolderPath),
+  generatedTypesPath: import_zod5.z.string().default(process.cwd() + "/src/@types"),
+  fileTempCachePath: import_zod5.z.string().optional()
+});
+
+// src/restura/sql/PsqlEngine.ts
+var import_core_utils5 = require("@redskytech/core-utils");
+var import_pg_diff_sync = __toESM(require("@wmfs/pg-diff-sync"));
+var import_pg_info = __toESM(require("@wmfs/pg-info"));
+var import_pg2 = __toESM(require("pg"));
+
 // src/restura/sql/PsqlPool.ts
 var import_pg = __toESM(require("pg"));
 
 // src/restura/sql/PsqlConnection.ts
+var import_crypto = __toESM(require("crypto"));
 var import_pg_format2 = __toESM(require("pg-format"));
 
 // src/restura/sql/PsqlUtils.ts
@@ -1456,7 +1596,6 @@ function SQL(strings, ...values) {
 }
 
 // src/restura/sql/PsqlConnection.ts
-var import_crypto = __toESM(require("crypto"));
 var PsqlConnection = class {
   constructor() {
     this.instanceId = import_crypto.default.randomUUID();
@@ -2308,121 +2447,6 @@ function schemaToPsqlType(column) {
   return column.type;
 }
 
-// src/restura/compareSchema.ts
-var import_lodash = __toESM(require("lodash.clonedeep"));
-var CompareSchema = class {
-  async diffSchema(newSchema, latestSchema, psqlEngine) {
-    const endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
-    const globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
-    const roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
-    let commands = "";
-    if (JSON.stringify(newSchema.database) !== JSON.stringify(latestSchema.database))
-      commands = await psqlEngine.diffDatabaseToSchema(newSchema);
-    const customTypes = newSchema.customTypes !== latestSchema.customTypes;
-    const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
-    return schemaPreview;
-  }
-  diffStringArray(newArray, originalArray) {
-    const stringsDiff = [];
-    const originalClone = new Set(originalArray);
-    newArray.forEach((item) => {
-      const originalIndex = originalClone.has(item);
-      if (!originalIndex) {
-        stringsDiff.push({
-          name: item,
-          changeType: "NEW"
-        });
-      } else {
-        originalClone.delete(item);
-      }
-    });
-    originalClone.forEach((item) => {
-      stringsDiff.push({
-        name: item,
-        changeType: "DELETED"
-      });
-    });
-    return stringsDiff;
-  }
-  diffEndPoints(newEndPoints, originalEndpoints) {
-    const originalClone = (0, import_lodash.default)(originalEndpoints);
-    const diffObj = [];
-    newEndPoints.forEach((endPoint) => {
-      const { path: path5, method } = endPoint;
-      const endPointIndex = originalClone.findIndex((original) => {
-        return original.path === endPoint.path && original.method === endPoint.method;
-      });
-      if (endPointIndex === -1) {
-        diffObj.push({
-          name: `${method} ${path5}`,
-          changeType: "NEW"
-        });
-      } else {
-        const original = originalClone.findIndex((original2) => {
-          return this.compareEndPoints(endPoint, original2);
-        });
-        if (original === -1) {
-          diffObj.push({
-            name: `${method} ${path5}`,
-            changeType: "MODIFIED"
-          });
-        }
-        originalClone.splice(endPointIndex, 1);
-      }
-    });
-    originalClone.forEach((original) => {
-      const { path: path5, method } = original;
-      diffObj.push({
-        name: `${method} ${path5}`,
-        changeType: "DELETED"
-      });
-    });
-    return diffObj;
-  }
-  compareEndPoints(endPoint1, endPoint2) {
-    return JSON.stringify(endPoint1) === JSON.stringify(endPoint2);
-  }
-};
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "diffSchema", 1);
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "diffStringArray", 1);
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "diffEndPoints", 1);
-__decorateClass([
-  boundMethod
-], CompareSchema.prototype, "compareEndPoints", 1);
-var compareSchema = new CompareSchema();
-var compareSchema_default = compareSchema;
-
-// src/restura/middleware/getMulterUploadSingleton.ts
-var import_multer = __toESM(require("multer"));
-var import_path3 = require("path");
-var os = __toESM(require("os"));
-var OneHundredMB = 100 * 1024 * 1024;
-var commonUpload = null;
-var getMulterUploadSingleton = (directory) => {
-  if (commonUpload) return commonUpload;
-  const storage = import_multer.default.diskStorage({
-    destination: directory || os.tmpdir(),
-    filename: function(request, file, cb) {
-      const extension = (0, import_path3.extname)(file.originalname);
-      const uniqueName = Date.now() + "-" + Math.round(Math.random() * 1e3);
-      cb(null, `${uniqueName}${extension}`);
-    }
-  });
-  commonUpload = (0, import_multer.default)({
-    storage,
-    limits: {
-      fileSize: OneHundredMB
-    }
-  });
-  return commonUpload;
-};
-
 // src/restura/utils/TempCache.ts
 var import_fs3 = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
@@ -2475,7 +2499,7 @@ var ResturaEngine = class {
    */
   async init(app, authenticationHandler, psqlConnectionPool) {
     this.resturaConfig = import_internal4.config.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);
@@ -2543,10 +2567,7 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the API has been successfully generated and written to the output file.
    */
   async generateApiFromSchema(outputFile, providedSchema) {
-    import_fs4.default.writeFileSync(
-      outputFile,
-      await apiGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
-    );
+    import_fs4.default.writeFileSync(outputFile, await apiGenerator(providedSchema));
   }
   /**
    * Generates a model from the provided schema and writes it to the specified output file.
@@ -2556,10 +2577,15 @@ var ResturaEngine = class {
    * @returns A promise that resolves when the model has been successfully written to the output file.
    */
   async generateModelFromSchema(outputFile, providedSchema) {
-    import_fs4.default.writeFileSync(
-      outputFile,
-      await modelGenerator(providedSchema, await this.generateHashForSchema(providedSchema))
-    );
+    import_fs4.default.writeFileSync(outputFile, await modelGenerator(providedSchema));
+  }
+  /**
+   * Generates the ambient module declaration for Restura global types and writes it to the specified output file.
+   * These types are used sometimes in the CustomTypes
+   * @param outputFile
+   */
+  generateResturaGlobalTypes(outputFile) {
+    import_fs4.default.writeFileSync(outputFile, resturaGlobalTypesGenerator());
   }
   /**
    * Retrieves the latest file system schema for Restura.
@@ -2581,28 +2607,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 = import_fs4.default.readFileSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const apiCreatedSchemaHash = (_b = (_a2 = apiFile.toString().match(/\((.*)\)/)) == null ? void 0 : _a2[1]) != null ? _b : "";
-    const modelFile = import_fs4.default.readFileSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
-    const modelCreatedSchemaHash = (_d = (_c = modelFile.toString().match(/\((.*)\)/)) == null ? void 0 : _c[1]) != null ? _d : "";
-    return {
-      schemaHash,
-      apiCreatedSchemaHash,
-      modelCreatedSchemaHash
-    };
-  }
   async reloadEndpoints() {
     this.schema = await this.getLatestFileSystemSchema();
     this.customTypeValidation = customTypeValidationGenerator(this.schema);
@@ -2634,27 +2638,7 @@ var ResturaEngine = class {
     if (!import_fs4.default.existsSync(this.resturaConfig.generatedTypesPath)) {
       import_fs4.default.mkdirSync(this.resturaConfig.generatedTypesPath, { recursive: true });
     }
-    const hasApiFile = import_fs4.default.existsSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"));
-    const hasModelsFile = import_fs4.default.existsSync(import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"));
-    if (!hasApiFile) {
-      await this.generateApiFromSchema(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
-    }
-    if (!hasModelsFile) {
-      await this.generateModelFromSchema(
-        import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
-        this.schema
-      );
-    }
-    const hashes = await this.getHashes(this.schema);
-    if (hashes.schemaHash !== hashes.apiCreatedSchemaHash) {
-      await this.generateApiFromSchema(import_path5.default.join(this.resturaConfig.generatedTypesPath, "api.d.ts"), this.schema);
-    }
-    if (hashes.schemaHash !== hashes.modelCreatedSchemaHash) {
-      await this.generateModelFromSchema(
-        import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
-        this.schema
-      );
-    }
+    this.updateTypes();
   }
   resturaAuthentication(req, res, next) {
     if (req.headers["x-auth-token"] !== this.resturaConfig.authToken) res.status(401).send("Unauthorized");
@@ -2686,6 +2670,7 @@ var ResturaEngine = class {
       import_path5.default.join(this.resturaConfig.generatedTypesPath, "models.d.ts"),
       this.schema
     );
+    this.generateResturaGlobalTypes(import_path5.default.join(this.resturaConfig.generatedTypesPath, "restura.d.ts"));
   }
   async getSchema(req, res) {
     res.send({ data: this.schema });
@@ -2693,9 +2678,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 });
@@ -2725,7 +2709,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;
@@ -2765,19 +2749,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 (0, import_crypto2.createHash)("sha256").update(schemaPrettyStr).digest("hex");
-  }
   async storeFileSystemSchema() {
     const schemaPrettyStr = await prettier3.format(JSON.stringify(this.schema), __spreadValues({
       parser: "json"