@restura/core 0.1.0-alpha.23 → 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,8 +818,9 @@ 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);
@@ -585,71 +850,11 @@ function apiGenerator(schema, schemaHash) {
   }));
 }
 
-// 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);
-        }
-      }
-    });
-  }
-  bindMethodsToInstance(instance) {
-    const proto = Object.getPrototypeOf(instance);
-    Object.getOwnPropertyNames(proto).forEach((key) => {
-      const property = instance[key];
-      if (typeof property === "function" && key !== "constructor") {
-        instance[key] = property.bind(instance);
-      }
-    });
-  }
-};
-var customApiFactory = new CustomApiFactory();
-var customApiFactory_default = customApiFactory;
-
-// src/restura/customTypeValidationGenerator.ts
+// 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) {
@@ -1178,7 +1464,7 @@ function getRequestData(req) {
 async function schemaValidation(req, res, next) {
   req.data = getRequestData(req);
   try {
-    resturaZodSchema.parse(req.data);
+    resturaSchema.parse(req.data);
     next();
   } catch (error) {
     logger.error(error);
@@ -1186,40 +1472,20 @@ async function schemaValidation(req, res, next) {
   }
 }
 
-// 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/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";
@@ -1231,6 +1497,7 @@ import pg2 from "pg";
 import pg from "pg";
 
 // src/restura/sql/PsqlConnection.ts
+import crypto from "crypto";
 import format3 from "pg-format";
 
 // src/restura/sql/PsqlUtils.ts
@@ -1283,7 +1550,6 @@ function SQL(strings, ...values) {
 }
 
 // src/restura/sql/PsqlConnection.ts
-import crypto from "crypto";
 var PsqlConnection = class {
   constructor() {
     this.instanceId = crypto.randomUUID();
@@ -1471,233 +1737,106 @@ var SqlEngine = class {
 
 // src/restura/sql/filterPsqlParser.ts
 import peg from "pegjs";
-var filterSqlGrammar = `
-{
-// ported from pg-format but intentionally will add double quotes to every column
- function quoteSqlIdentity(value) {
-    if (value === undefined || value === null) {
-        throw new Error('SQL identifier cannot be null or undefined');
-    } else if (value === false) {
-        return '"f"';
-    } else if (value === true) {
-        return '"t"';
-    } else if (value instanceof Date) {
-        // return '"' + formatDate(value.toISOString()) + '"';
-    } else if (value instanceof Buffer) {
-        throw new Error('SQL identifier cannot be a buffer');
-    } else if (Array.isArray(value) === true) {
-        var temp = [];
-        for (var i = 0; i < value.length; i++) {
-            if (Array.isArray(value[i]) === true) {
-                throw new Error('Nested array to grouped list conversion is not supported for SQL identifier');
-            } else {
-                // temp.push(quoteIdent(value[i]));
-            }
-        }
-        return temp.toString();
-    } else if (value === Object(value)) {
-        throw new Error('SQL identifier cannot be an object');
-    }
-
-    var ident = value.toString().slice(0); // create copy
-
-    // do not quote a valid, unquoted identifier
-    // if (/^[a-z_][a-z0-9_$]*$/.test(ident) === true && isReserved(ident) === false) {
-    //     return ident;
-    // }
-
-    var quoted = '"';
-
-    for (var i = 0; i < ident.length; i++) {
-        var c = ident[i];
-        if (c === '"') {
-            quoted += c + c;
-        } else {
-            quoted += c;
-        }
-    }
-
-    quoted += '"';
-
-    return quoted;
-};
-}
-
-start = expressionList
-
-_ = [ \\t\\r\\n]*  // Matches spaces, tabs, and line breaks
-
-expressionList =
-    leftExpression:expression _ operator:operator _ rightExpression:expressionList 
-    { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
-    / expression
-
-expression = 
-    negate:negate? _ "(" _ "column" _ ":"  column:column _ ","? _ value:value? ","? _ type:type? _ ")"_
-    {return \`\${negate? " NOT " : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
-    /
-    negate:negate?"("expression:expressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
-
-negate = "!"
-    
-operator = "and"i / "or"i
-
-	   
-column = left:text "." right:text { return  \`\${quoteSqlIdentity(left)}.\${quoteSqlIdentity(right)}\`; } 
-    / 
-    text:text { return quoteSqlIdentity(text); } 
-    
-
-text = text:[a-z0-9 \\t\\r\\n\\-_:@]i+ { return text.join(""); }
-
-type = "type" _ ":" _ type:typeString { return type; }
-typeString = text:"startsWith" { return function(column, value) { return \`\${column} ILIKE '\${format.literal(value).slice(1,-1)}%'\`; } } /
-    text:"endsWith"  { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}'\`; } } /
-    text:"contains" { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}%'\`; } } /
-    text:"exact" { return function(column, value)    { return \`\${column} = '\${format.literal(value).slice(1,-1)}'\`; } } /
-    text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= '\${format.literal(value).slice(1,-1)}'\`; } } /
-    text:"greaterThan" { return function(column, value) { return \`\${column} > '\${format.literal(value).slice(1,-1)}'\`; } } /
-    text:"lessThanEqual" { return function(column, value) { return \`\${column} <= '\${format.literal(value).slice(1,-1)}'\`; } } /
-    text:"lessThan" { return function(column, value) { return \`\${column} < '\${format.literal(value).slice(1,-1)}'\`; } } / 
-    text:"isNull"   { return function(column, value) { return \`isNull(\${column})\`; } } 
-
-value = "value" _ ":" value:text { return value; }
-
-
-`;
-var filterPsqlParser = peg.generate(filterSqlGrammar, {
-  format: "commonjs",
-  dependencies: { format: "pg-format" }
-});
-var filterPsqlParser_default = filterPsqlParser;
-
-// 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 }
-    );
-  }
-  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 }
-    );
-  }
-  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;
-      }
+var filterSqlGrammar = `
+{
+// ported from pg-format but intentionally will add double quotes to every column
+ function quoteSqlIdentity(value) {
+    if (value === undefined || value === null) {
+        throw new Error('SQL identifier cannot be null or undefined');
+    } else if (value === false) {
+        return '"f"';
+    } else if (value === true) {
+        return '"t"';
+    } else if (value instanceof Date) {
+        // return '"' + formatDate(value.toISOString()) + '"';
+    } else if (value instanceof Buffer) {
+        throw new Error('SQL identifier cannot be a buffer');
+    } else if (Array.isArray(value) === true) {
+        var temp = [];
+        for (var i = 0; i < value.length; i++) {
+            if (Array.isArray(value[i]) === true) {
+                throw new Error('Nested array to grouped list conversion is not supported for SQL identifier');
+            } else {
+                // temp.push(quoteIdent(value[i]));
+            }
+        }
+        return temp.toString();
+    } else if (value === Object(value)) {
+        throw new Error('SQL identifier cannot be an object');
     }
-    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];
+
+    var ident = value.toString().slice(0); // create copy
+
+    // do not quote a valid, unquoted identifier
+    // if (/^[a-z_][a-z0-9_$]*$/.test(ident) === true && isReserved(ident) === false) {
+    //     return ident;
+    // }
+
+    var quoted = '"';
+
+    for (var i = 0; i < ident.length; i++) {
+        var c = ident[i];
+        if (c === '"') {
+            quoted += c + c;
+        } else {
+            quoted += c;
         }
-      } else {
-        changed[i] = record[i];
-      }
     }
-  }
-  return changed;
+
+    quoted += '"';
+
+    return quoted;
+};
 }
 
+start = expressionList
+
+_ = [ \\t\\r\\n]*  // Matches spaces, tabs, and line breaks
+
+expressionList =
+    leftExpression:expression _ operator:operator _ rightExpression:expressionList 
+    { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
+    / expression
+
+expression = 
+    negate:negate? _ "(" _ "column" _ ":"  column:column _ ","? _ value:value? ","? _ type:type? _ ")"_
+    {return \`\${negate? " NOT " : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
+    /
+    negate:negate?"("expression:expressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
+
+negate = "!"
+    
+operator = "and"i / "or"i
+
+	   
+column = left:text "." right:text { return  \`\${quoteSqlIdentity(left)}.\${quoteSqlIdentity(right)}\`; } 
+    / 
+    text:text { return quoteSqlIdentity(text); } 
+    
+
+text = text:[a-z0-9 \\t\\r\\n\\-_:@]i+ { return text.join(""); }
+
+type = "type" _ ":" _ type:typeString { return type; }
+typeString = text:"startsWith" { return function(column, value) { return \`\${column} ILIKE '\${format.literal(value).slice(1,-1)}%'\`; } } /
+    text:"endsWith"  { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"contains" { return function(column, value) { return \`\${column} ILIKE '%\${format.literal(value).slice(1,-1)}%'\`; } } /
+    text:"exact" { return function(column, value)    { return \`\${column} = '\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= '\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"greaterThan" { return function(column, value) { return \`\${column} > '\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"lessThanEqual" { return function(column, value) { return \`\${column} <= '\${format.literal(value).slice(1,-1)}'\`; } } /
+    text:"lessThan" { return function(column, value) { return \`\${column} < '\${format.literal(value).slice(1,-1)}'\`; } } / 
+    text:"isNull"   { return function(column, value) { return \`isNull(\${column})\`; } } 
+
+value = "value" _ ":" value:text { return value; }
+
+
+`;
+var filterPsqlParser = peg.generate(filterSqlGrammar, {
+  format: "commonjs",
+  dependencies: { format: "pg-format" }
+});
+var filterPsqlParser_default = filterPsqlParser;
+
 // src/restura/sql/PsqlEngine.ts
 var { Client } = pg2;
 var systemUser = {
@@ -1726,7 +1865,7 @@ var PsqlEngine = class extends SqlEngine {
       database: this.psqlConnectionPool.poolConfig.database,
       password: this.psqlConnectionPool.poolConfig.password,
       port: this.psqlConnectionPool.poolConfig.port,
-      connectionTimeoutMillis: 2e3
+      connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
     });
     await this.triggerClient.connect();
     const promises = [];
@@ -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"