@restura/core 1.4.0 → 1.5.0

package/dist/index.js

@@ -878,7 +878,7 @@ declare namespace Restura {
 }
 
 // src/restura/restura.ts
-import { ObjectUtils as ObjectUtils5, StringUtils as StringUtils3 } from "@redskytech/core-utils";
+import { ObjectUtils as ObjectUtils4, 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
@@ -1093,7 +1093,120 @@ import fs2 from "fs";
 import path2, { resolve } from "path";
 import tmp from "tmp";
 import * as TJS from "typescript-json-schema";
-function customTypeValidationGenerator(currentSchema) {
+
+// src/restura/generators/schemaGeneratorUtils.ts
+function buildRouteSchema(requestParams) {
+  const properties = {};
+  const required = [];
+  for (const param of requestParams) {
+    if (param.required) {
+      required.push(param.name);
+    }
+    const propertySchema = buildPropertySchemaFromRequest(param);
+    properties[param.name] = propertySchema;
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 && { required },
+    // Only include if not empty
+    additionalProperties: false
+  };
+}
+function buildPropertySchemaFromRequest(param) {
+  const propertySchema = {};
+  const typeCheckValidator = param.validator.find((v) => v.type === "TYPE_CHECK");
+  const oneOfValidator = param.validator.find((v) => v.type === "ONE_OF");
+  if (oneOfValidator && Array.isArray(oneOfValidator.value)) {
+    propertySchema.enum = oneOfValidator.value;
+    if (!typeCheckValidator && oneOfValidator.value.length > 0) {
+      const firstValue = oneOfValidator.value[0];
+      propertySchema.type = typeof firstValue === "number" ? "number" : "string";
+      return propertySchema;
+    }
+  }
+  if (!typeCheckValidator) {
+    return propertySchema;
+  }
+  const typeValue = typeCheckValidator.value;
+  if (typeof typeValue === "string" && typeValue.endsWith("[]")) {
+    const itemType = typeValue.replace("[]", "");
+    if (param.isNullable) {
+      propertySchema.type = ["array", "null"];
+    } else {
+      propertySchema.type = "array";
+    }
+    propertySchema.items = {
+      type: mapTypeToJsonSchemaType(itemType)
+    };
+    applyArrayValidators(propertySchema, param);
+  } else {
+    if (param.isNullable) {
+      propertySchema.type = [mapTypeToJsonSchemaType(typeValue), "null"];
+    } else {
+      propertySchema.type = mapTypeToJsonSchemaType(typeValue);
+    }
+    const type = propertySchema.type;
+    const isNumericType = type === "number" || type === "integer" || Array.isArray(type) && (type.includes("number") || type.includes("integer"));
+    const isStringType = type === "string" || Array.isArray(type) && type.includes("string");
+    if (isNumericType) {
+      applyNumericValidators(propertySchema, param);
+    } else if (isStringType) {
+      applyStringValidators(propertySchema, param);
+    }
+  }
+  return propertySchema;
+}
+function mapTypeToJsonSchemaType(type) {
+  if (typeof type !== "string") {
+    throw new Error(`Invalid type for JSON Schema mapping: ${type}`);
+  }
+  switch (type) {
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "object";
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+function applyNumericValidators(propertySchema, param) {
+  for (const validator of param.validator) {
+    if (validator.type === "MIN" && typeof validator.value === "number") {
+      propertySchema.minimum = validator.value;
+    }
+    if (validator.type === "MAX" && typeof validator.value === "number") {
+      propertySchema.maximum = validator.value;
+    }
+  }
+}
+function applyStringValidators(propertySchema, param) {
+  for (const validator of param.validator) {
+    if (validator.type === "MIN" && typeof validator.value === "number") {
+      propertySchema.minLength = validator.value;
+    }
+    if (validator.type === "MAX" && typeof validator.value === "number") {
+      propertySchema.maxLength = validator.value;
+    }
+  }
+}
+function applyArrayValidators(propertySchema, param) {
+  for (const validator of param.validator) {
+    if (validator.type === "MIN" && typeof validator.value === "number") {
+      propertySchema.minItems = validator.value;
+    }
+    if (validator.type === "MAX" && typeof validator.value === "number") {
+      propertySchema.maxItems = validator.value;
+    }
+  }
+}
+
+// src/restura/generators/customTypeValidationGenerator.ts
+function customTypeValidationGenerator(currentSchema, ignoreGeneratedTypes = false) {
   const schemaObject = {};
   const customInterfaceNames = currentSchema.customTypes.map((customType) => {
     const matches = customType.match(/(?<=interface\s)(\w+)|(?<=type\s)(\w+)/g);
@@ -1111,9 +1224,11 @@ function customTypeValidationGenerator(currentSchema) {
   const program = TJS.getProgramFromFiles(
     [
       resolve(temporaryFile.name),
-      path2.join(restura.resturaConfig.generatedTypesPath, "restura.d.ts"),
-      path2.join(restura.resturaConfig.generatedTypesPath, "models.d.ts"),
-      path2.join(restura.resturaConfig.generatedTypesPath, "api.d.ts")
+      ...ignoreGeneratedTypes ? [] : [
+        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
   );
@@ -1124,6 +1239,35 @@ function customTypeValidationGenerator(currentSchema) {
     schemaObject[item] = ddlSchema || {};
   });
   temporaryFile.removeCallback();
+  for (const endpoint of currentSchema.endpoints) {
+    for (const route of endpoint.routes) {
+      if (route.type !== "CUSTOM_ONE" && route.type !== "CUSTOM_ARRAY" && route.type !== "CUSTOM_PAGED") continue;
+      if (!route.request || !Array.isArray(route.request)) continue;
+      const routeKey = `${route.method}:${route.path}`;
+      schemaObject[routeKey] = buildRouteSchema(route.request);
+    }
+  }
+  return schemaObject;
+}
+
+// src/restura/generators/standardTypeValidationGenerator.ts
+function standardTypeValidationGenerator(currentSchema) {
+  const schemaObject = {};
+  for (const endpoint of currentSchema.endpoints) {
+    for (const route of endpoint.routes) {
+      if (route.type !== "ONE" && route.type !== "ARRAY" && route.type !== "PAGED") continue;
+      const routeKey = `${route.method}:${route.path}`;
+      if (!route.request || route.request.length === 0) {
+        schemaObject[routeKey] = {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        };
+      } else {
+        schemaObject[routeKey] = buildRouteSchema(route.request);
+      }
+    }
+  }
   return schemaObject;
 }
 
@@ -1496,174 +1640,41 @@ async function isSchemaValid(schemaToCheck) {
 }
 
 // src/restura/validators/requestValidator.ts
-import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
 import jsonschema from "jsonschema";
-import { z as z4 } from "zod";
-
-// src/restura/utils/utils.ts
-function addQuotesToStrings(variable) {
-  if (typeof variable === "string") {
-    return `'${variable}'`;
-  } else if (Array.isArray(variable)) {
-    const arrayWithQuotes = variable.map(addQuotesToStrings);
-    return arrayWithQuotes;
-  } else {
-    return variable;
-  }
-}
-function sortObjectKeysAlphabetically(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map(sortObjectKeysAlphabetically);
-  } else if (obj !== null && typeof obj === "object") {
-    return Object.keys(obj).sort().reduce((sorted, key) => {
-      sorted[key] = sortObjectKeysAlphabetically(obj[key]);
-      return sorted;
-    }, {});
-  }
-  return obj;
-}
-
-// src/restura/validators/requestValidator.ts
-function requestValidator(req, routeData, validationSchema) {
-  const requestData = getRequestData(req);
-  req.data = requestData;
-  if (routeData.request === void 0) {
-    if (routeData.type !== "CUSTOM_ONE" && routeData.type !== "CUSTOM_ARRAY" && routeData.type !== "CUSTOM_PAGED")
-      throw new RsError("BAD_REQUEST", `No request parameters provided for standard request.`);
+function requestValidator(req, routeData, customValidationSchema, standardValidationSchema) {
+  let schemaForCoercion;
+  if (routeData.type === "ONE" || routeData.type === "ARRAY" || routeData.type === "PAGED") {
+    const routeKey = `${routeData.method}:${routeData.path}`;
+    schemaForCoercion = standardValidationSchema[routeKey];
+    if (!schemaForCoercion) {
+      throw new RsError("BAD_REQUEST", `No schema found for standard request route: ${routeKey}.`);
+    }
+  } else if (routeData.type === "CUSTOM_ONE" || routeData.type === "CUSTOM_ARRAY" || routeData.type === "CUSTOM_PAGED") {
     if (!routeData.responseType) throw new RsError("BAD_REQUEST", `No response type defined for custom request.`);
-    if (!routeData.requestType) throw new RsError("BAD_REQUEST", `No request type defined for custom request.`);
-    const currentInterface = validationSchema[routeData.requestType];
-    const validator = new jsonschema.Validator();
-    const strictSchema = {
+    if (!routeData.requestType && !routeData.request)
+      throw new RsError("BAD_REQUEST", `No request type defined for custom request.`);
+    const routeKey = `${routeData.method}:${routeData.path}`;
+    const currentInterface = customValidationSchema[routeData.requestType || routeKey];
+    schemaForCoercion = {
       ...currentInterface,
       additionalProperties: false
     };
-    const executeValidation = validator.validate(req.data, strictSchema);
-    if (!executeValidation.valid) {
-      throw new RsError(
-        "BAD_REQUEST",
-        `Request custom setup has failed the following check: (${executeValidation.errors})`
-      );
-    }
-    return;
-  }
-  Object.keys(req.data).forEach((requestParamName) => {
-    const requestParam = routeData.request.find((param) => param.name === requestParamName);
-    if (!requestParam) {
-      throw new RsError("BAD_REQUEST", `Request param (${requestParamName}) is not allowed`);
-    }
-  });
-  routeData.request.forEach((requestParam) => {
-    const requestValue = requestData[requestParam.name];
-    if (requestParam.required && requestValue === void 0)
-      throw new RsError("BAD_REQUEST", `Request param (${requestParam.name}) is required but missing`);
-    else if (!requestParam.required && requestValue === void 0) return;
-    validateRequestSingleParam(requestValue, requestParam);
-  });
-}
-function validateRequestSingleParam(requestValue, requestParam) {
-  if (requestParam.isNullable && requestValue === null) return;
-  requestParam.validator.forEach((validator) => {
-    switch (validator.type) {
-      case "TYPE_CHECK":
-        performTypeCheck(requestValue, validator, requestParam.name);
-        break;
-      case "MIN":
-        performMinCheck(requestValue, validator, requestParam.name);
-        break;
-      case "MAX":
-        performMaxCheck(requestValue, validator, requestParam.name);
-        break;
-      case "ONE_OF":
-        performOneOfCheck(requestValue, validator, requestParam.name);
-        break;
-    }
-  });
-}
-function isValidType(type, requestValue) {
-  try {
-    expectValidType(type, requestValue);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function expectValidType(type, requestValue) {
-  if (type === "number") {
-    return z4.number().parse(requestValue);
-  }
-  if (type === "string") {
-    return z4.string().parse(requestValue);
-  }
-  if (type === "boolean") {
-    return z4.boolean().parse(requestValue);
-  }
-  if (type === "string[]") {
-    return z4.array(z4.string()).parse(requestValue);
-  }
-  if (type === "number[]") {
-    return z4.array(z4.number()).parse(requestValue);
-  }
-  if (type === "any[]") {
-    return z4.array(z4.any()).parse(requestValue);
-  }
-  if (type === "object") {
-    return z4.object({}).strict().parse(requestValue);
-  }
-}
-function performTypeCheck(requestValue, validator, requestParamName) {
-  if (!isValidType(validator.value, requestValue)) {
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${addQuotesToStrings(requestValue)}) is not of type (${validator.value})`
-    );
+  } else {
+    throw new RsError("BAD_REQUEST", `Invalid route type: ${routeData.type}`);
   }
-  try {
-    validatorDataSchemeValue.parse(validator.value);
-  } catch {
-    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value}) is not a valid type`);
+  const requestData = getRequestData(req, schemaForCoercion);
+  req.data = requestData;
+  const validator = new jsonschema.Validator();
+  const executeValidation = validator.validate(req.data, schemaForCoercion);
+  if (!executeValidation.valid) {
+    const errorMessages = executeValidation.errors.map((err) => {
+      const property = err.property.replace("instance.", "");
+      return `${property}: ${err.message}`;
+    }).join(", ");
+    throw new RsError("BAD_REQUEST", `Request validation failed: ${errorMessages}`);
   }
 }
-function expectOnlyNumbers(requestValue, validator, requestParamName) {
-  if (!isValueNumber(requestValue))
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${requestValue}) is not of type number`
-    );
-  if (!isValueNumber(validator.value))
-    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value} is not of type number`);
-}
-function performMinCheck(requestValue, validator, requestParamName) {
-  expectOnlyNumbers(requestValue, validator, requestParamName);
-  if (requestValue < validator.value)
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${requestValue}) is less than (${validator.value})`
-    );
-}
-function performMaxCheck(requestValue, validator, requestParamName) {
-  expectOnlyNumbers(requestValue, validator, requestParamName);
-  if (requestValue > validator.value)
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${requestValue}) is more than (${validator.value})`
-    );
-}
-function performOneOfCheck(requestValue, validator, requestParamName) {
-  if (!ObjectUtils2.isArrayWithData(validator.value))
-    throw new RsError("SCHEMA_ERROR", `Schema validator value (${validator.value}) is not of type array`);
-  if (typeof requestValue === "object")
-    throw new RsError("BAD_REQUEST", `Request param (${requestParamName}) is not of type string or number`);
-  if (!validator.value.includes(requestValue))
-    throw new RsError(
-      "BAD_REQUEST",
-      `Request param (${requestParamName}) with value (${requestValue}) is not one of (${validator.value.join(", ")})`
-    );
-}
-function isValueNumber(value) {
-  return !isNaN(Number(value));
-}
-function getRequestData(req) {
+function getRequestData(req, schema) {
   let body = "";
   if (req.method === "GET" || req.method === "DELETE") {
     body = "query";
@@ -1671,50 +1682,74 @@ function getRequestData(req) {
     body = "body";
   }
   const bodyData = req[body];
-  if (bodyData && body === "query") {
-    const normalizedData = {};
-    for (const attr in bodyData) {
-      if (attr.includes("[]") && !(bodyData[attr] instanceof Array)) {
-        bodyData[attr] = [bodyData[attr]];
+  if (bodyData && body === "query" && schema) {
+    return coerceBySchema(bodyData, schema);
+  }
+  return bodyData;
+}
+function coerceBySchema(data, schema) {
+  const normalized = {};
+  const properties = schema.properties || {};
+  for (const attr in data) {
+    const cleanAttr = attr.replace(/\[\]$/, "");
+    const isArrayNotation = attr.includes("[]");
+    let value = data[attr];
+    const propertySchema = properties[cleanAttr];
+    if (isArrayNotation && !Array.isArray(value)) {
+      value = [value];
+    }
+    if (!propertySchema) {
+      normalized[cleanAttr] = value;
+      continue;
+    }
+    if (Array.isArray(value)) {
+      const itemSchema = Array.isArray(propertySchema.items) ? propertySchema.items[0] : propertySchema.items || { type: "string" };
+      normalized[cleanAttr] = value.map((item) => coerceValue(item, itemSchema));
+    } else {
+      normalized[cleanAttr] = coerceValue(value, propertySchema);
+    }
+  }
+  return normalized;
+}
+function coerceValue(value, propertySchema) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  const targetType = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
+  if (value === "") {
+    return targetType === "string" ? "" : void 0;
+  }
+  switch (targetType) {
+    case "number":
+    case "integer":
+      const num = Number(value);
+      return isNaN(num) ? value : num;
+    case "boolean":
+      if (value === "true") return true;
+      if (value === "false") return false;
+      if (typeof value === "string") {
+        return value === "true" || value === "1";
       }
-      const cleanAttr = attr.replace(/\[\]$/, "");
-      if (bodyData[attr] instanceof Array) {
-        const parsedList = bodyData[attr].map((value) => {
-          if (value === "true") return true;
-          if (value === "false") return false;
-          if (value === void 0) return void 0;
-          if (value === "") return "";
-          const parsed = ObjectUtils2.safeParse(value);
-          return isNaN(Number(parsed)) ? parsed : Number(parsed);
-        });
-        normalizedData[cleanAttr] = parsedList;
-      } else {
-        let value = bodyData[attr];
-        if (value === "true") {
-          value = true;
-        } else if (value === "false") {
-          value = false;
-        } else if (value === void 0) {
-          value = void 0;
-        } else if (value === "") {
-          value = "";
-        } else {
-          value = ObjectUtils2.safeParse(value);
-          if (!isNaN(Number(value))) {
-            value = Number(value);
-          }
+      return Boolean(value);
+    case "string":
+      return String(value);
+    case "object":
+      if (typeof value === "string") {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value;
         }
-        normalizedData[cleanAttr] = value;
       }
-    }
-    return normalizedData;
+      return value;
+    default:
+      return value;
   }
-  return bodyData;
 }
 
 // src/restura/middleware/schemaValidation.ts
 async function schemaValidation(req, res, next) {
-  req.data = getRequestData(req);
+  req.data = getRequestData(req, {});
   try {
     resturaSchema.parse(req.data);
     next();
@@ -1725,22 +1760,22 @@ async function schemaValidation(req, res, next) {
 }
 
 // src/restura/schemas/resturaConfigSchema.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var isTsx = process.argv[1]?.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(),
-  scratchDatabaseSuffix: z5.string().optional()
+var resturaConfigSchema = z4.object({
+  authToken: z4.string().min(1, "Missing Restura Auth Token"),
+  sendErrorStackTrace: z4.boolean().default(false),
+  schemaFilePath: z4.string().default(process.cwd() + "/restura.schema.json"),
+  customApiFolderPath: z4.string().default(process.cwd() + customApiFolderPath),
+  generatedTypesPath: z4.string().default(process.cwd() + "/src/@types"),
+  fileTempCachePath: z4.string().optional(),
+  scratchDatabaseSuffix: z4.string().optional()
 });
 
 // src/restura/sql/PsqlEngine.ts
-import { ObjectUtils as ObjectUtils4 } from "@redskytech/core-utils";
+import { ObjectUtils as ObjectUtils3 } from "@redskytech/core-utils";
 import getDiff from "@wmfs/pg-diff-sync";
 import pgInfo from "@wmfs/pg-info";
 import pg2 from "pg";
@@ -1752,7 +1787,7 @@ import pg from "pg";
 import crypto from "crypto";
 import format2 from "pg-format";
 import { format as sqlFormat } from "sql-formatter";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 
 // src/restura/sql/PsqlUtils.ts
 import format from "pg-format";
@@ -1788,13 +1823,15 @@ function insertObjectQuery(table, obj) {
 INSERT INTO "${table}" (${columns})
                  VALUES (${values})
                  RETURNING *`;
-  query = query.replace(/'(\?)'/, "?");
+  query = query.replace(/'(\?)'/g, "?");
   return query;
 }
 function updateObjectQuery(table, obj, whereStatement, incrementSyncVersion = false) {
   const setArray = [];
   for (const i in obj) {
-    setArray.push(`${escapeColumnName(i)} = ` + SQL`${obj[i]}`);
+    let value = SQL`${obj[i]}`;
+    value = value.replace(/'(\?)'/g, "?");
+    setArray.push(`${escapeColumnName(i)} = ` + value);
   }
   if (incrementSyncVersion) {
     setArray.push(`"syncVersion" = "syncVersion" + 1`);
@@ -1804,7 +1841,7 @@ function updateObjectQuery(table, obj, whereStatement, incrementSyncVersion = fa
 		SET ${setArray.join(", ")} ${whereStatement}
 	RETURNING *`;
 }
-function isValueNumber2(value) {
+function isValueNumber(value) {
   return !isNaN(Number(value));
 }
 function SQL(strings, ...values) {
@@ -1856,10 +1893,10 @@ var PsqlConnection = class {
     try {
       return zodSchema.parse(result);
     } catch (error) {
-      if (error instanceof z6.ZodError) {
+      if (error instanceof z5.ZodError) {
         logger.error("Invalid data returned from database:");
         logger.silly("\n" + JSON.stringify(result, null, 2));
-        logger.error("\n" + z6.prettifyError(error));
+        logger.error("\n" + z5.prettifyError(error));
       } else {
         logger.error(error);
       }
@@ -1887,12 +1924,12 @@ var PsqlConnection = class {
   async runQuerySchema(query, params, requesterDetails, zodSchema) {
     const result = await this.runQuery(query, params, requesterDetails);
     try {
-      return z6.array(zodSchema).parse(result);
+      return z5.array(zodSchema).parse(result);
     } catch (error) {
-      if (error instanceof z6.ZodError) {
+      if (error instanceof z5.ZodError) {
         logger.error("Invalid data returned from database:");
         logger.silly("\n" + JSON.stringify(result, null, 2));
-        logger.error("\n" + z6.prettifyError(error));
+        logger.error("\n" + z5.prettifyError(error));
       } else {
         logger.error(error);
       }
@@ -1965,7 +2002,7 @@ var PsqlPool = class extends PsqlConnection {
 };
 
 // src/restura/sql/SqlEngine.ts
-import { ObjectUtils as ObjectUtils3 } from "@redskytech/core-utils";
+import { ObjectUtils as ObjectUtils2 } from "@redskytech/core-utils";
 var SqlEngine = class {
   async runQueryForRoute(req, routeData, schema) {
     if (!this.canRequesterAccessTable(
@@ -2008,18 +2045,18 @@ var SqlEngine = class {
       const columnSchema = tableSchema.columns.find((item2) => item2.name === columnName);
       if (!columnSchema)
         throw new RsError("SCHEMA_ERROR", `Column ${columnName} not found in table ${tableName}`);
-      if (ObjectUtils3.isArrayWithData(columnSchema.roles)) {
+      if (ObjectUtils2.isArrayWithData(columnSchema.roles)) {
         if (!requesterRole) return false;
         return columnSchema.roles.includes(requesterRole);
       }
-      if (ObjectUtils3.isArrayWithData(columnSchema.scopes)) {
+      if (ObjectUtils2.isArrayWithData(columnSchema.scopes)) {
         if (!requesterScopes) return false;
         return columnSchema.scopes.every((scope) => requesterScopes.includes(scope));
       }
       return true;
     }
     if (item.subquery) {
-      return ObjectUtils3.isArrayWithData(
+      return ObjectUtils2.isArrayWithData(
         item.subquery.properties.filter((nestedItem) => {
           return this.canRequesterAccessColumn(requesterRole, requesterScopes, schema, nestedItem, joins);
         })
@@ -2029,11 +2066,11 @@ var SqlEngine = class {
   }
   canRequesterAccessTable(requesterRole, requesterScopes, schema, tableName) {
     const tableSchema = this.getTableSchema(schema, tableName);
-    if (ObjectUtils3.isArrayWithData(tableSchema.roles)) {
+    if (ObjectUtils2.isArrayWithData(tableSchema.roles)) {
       if (!requesterRole) return false;
       return tableSchema.roles.includes(requesterRole);
     }
-    if (ObjectUtils3.isArrayWithData(tableSchema.scopes)) {
+    if (ObjectUtils2.isArrayWithData(tableSchema.scopes)) {
       if (!requesterScopes) return false;
       return tableSchema.scopes.some((scope) => requesterScopes.includes(scope));
     }
@@ -2309,7 +2346,7 @@ var PsqlEngine = class extends SqlEngine {
       });
       this.triggerClient.on("notification", async (msg) => {
         if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
-          const payload = ObjectUtils4.safeParse(msg.payload);
+          const payload = ObjectUtils3.safeParse(msg.payload);
           await this.handleTrigger(payload, msg.channel.toUpperCase());
         }
       });
@@ -2483,7 +2520,7 @@ var PsqlEngine = class extends SqlEngine {
   }
   createNestedSelect(req, schema, item, routeData, sqlParams) {
     if (!item.subquery) return "";
-    if (!ObjectUtils4.isArrayWithData(
+    if (!ObjectUtils3.isArrayWithData(
       item.subquery.properties.filter((nestedItem) => {
         return this.canRequesterAccessColumn(
           req.requesterDetails.role,
@@ -2519,7 +2556,7 @@ var PsqlEngine = class extends SqlEngine {
       }
       return `'${nestedItem.name}', ${escapeColumnName(nestedItem.selector)}`;
     }).filter(Boolean).join(", ")}
-						)) 
+						))
 						FROM
 							"${item.subquery.table}"
 							${this.generateJoinStatements(req, item.subquery.joins, item.subquery.table, routeData, schema, sqlParams)}
@@ -2627,7 +2664,7 @@ var PsqlEngine = class extends SqlEngine {
       );
       const [pageResults, totalResponse] = await Promise.all([pagePromise, totalPromise]);
       let total = 0;
-      if (ObjectUtils4.isArrayWithData(totalResponse)) {
+      if (ObjectUtils3.isArrayWithData(totalResponse)) {
         total = totalResponse[0].total;
       }
       return { data: pageResults, total };
@@ -2657,14 +2694,9 @@ var PsqlEngine = class extends SqlEngine {
     }
     let incrementSyncVersion = false;
     if (table.columns.find((column) => column.name === "syncVersion")) incrementSyncVersion = true;
-    for (const assignment of routeData.assignments) {
-      const column = table.columns.find((column2) => column2.name === assignment.name);
-      if (!column) continue;
-      const assignmentEscaped = escapeColumnName(assignment.name);
-      if (SqlUtils.convertDatabaseTypeToTypescript(column.type) === "number")
-        bodyNoId[assignmentEscaped] = Number(assignment.value);
-      else bodyNoId[assignmentEscaped] = assignment.value;
-    }
+    (routeData.assignments || []).forEach((assignment) => {
+      bodyNoId[assignment.name] = this.replaceParamKeywords(assignment.value, routeData, req, sqlParams);
+    });
     let whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
     const originalWhereClause = whereClause;
     const originalSqlParams = [...sqlParams];
@@ -3088,6 +3120,19 @@ var TempCache = class {
   }
 };
 
+// src/restura/utils/utils.ts
+function sortObjectKeysAlphabetically(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectKeysAlphabetically);
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj).sort().reduce((sorted, key) => {
+      sorted[key] = sortObjectKeysAlphabetically(obj[key]);
+      return sorted;
+    }, {});
+  }
+  return obj;
+}
+
 // src/restura/restura.ts
 var ResturaEngine = class {
   // Make public so other modules can access without re-parsing the config
@@ -3106,6 +3151,7 @@ var ResturaEngine = class {
   responseValidator;
   authenticationHandler;
   customTypeValidation;
+  standardTypeValidation;
   psqlConnectionPool;
   psqlEngine;
   /**
@@ -3215,7 +3261,7 @@ var ResturaEngine = class {
       throw new Error("Missing restura schema file");
     }
     const schemaFileData = fs4.readFileSync(this.resturaConfig.schemaFilePath, { encoding: "utf8" });
-    const schema = ObjectUtils5.safeParse(schemaFileData);
+    const schema = ObjectUtils4.safeParse(schemaFileData);
     const isValid = await isSchemaValid(schema);
     if (!isValid) {
       logger.error("Schema is not valid");
@@ -3226,6 +3272,7 @@ var ResturaEngine = class {
   async reloadEndpoints() {
     this.schema = await this.getLatestFileSystemSchema();
     this.customTypeValidation = customTypeValidationGenerator(this.schema);
+    this.standardTypeValidation = standardTypeValidationGenerator(this.schema);
     this.resturaRouter = express.Router();
     this.resetPublicEndpoints();
     let routeCount = 0;
@@ -3325,7 +3372,12 @@ var ResturaEngine = class {
       const routeData = this.getRouteData(req.method, req.baseUrl, req.path);
       this.validateAuthorization(req, routeData);
       await this.getMulterFilesIfAny(req, res, routeData);
-      requestValidator(req, routeData, this.customTypeValidation);
+      requestValidator(
+        req,
+        routeData,
+        this.customTypeValidation,
+        this.standardTypeValidation
+      );
       if (this.isCustomRoute(routeData)) {
         await this.runCustomRouteLogic(req, res, routeData);
         return;
@@ -3502,7 +3554,7 @@ export {
   filterPsqlParser_default as filterPsqlParser,
   insertObjectQuery,
   isSchemaValid,
-  isValueNumber2 as isValueNumber,
+  isValueNumber,
   logger,
   modelGenerator,
   questionMarksToOrderedParams,