@restura/core 1.6.0 → 1.8.0

package/dist/index.js

@@ -14,6 +14,94 @@ import { config } from "@restura/internal";
 import pino from "pino";
 import pinoPretty from "pino-pretty";
 
+// src/restura/RsError.ts
+var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
+  HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HtmlStatusCodes2[HtmlStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HtmlStatusCodes2[HtmlStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HtmlStatusCodes2[HtmlStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HtmlStatusCodes2[HtmlStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HtmlStatusCodes2[HtmlStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HtmlStatusCodes2[HtmlStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
+  HtmlStatusCodes2[HtmlStatusCodes2["GONE"] = 410] = "GONE";
+  HtmlStatusCodes2[HtmlStatusCodes2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HtmlStatusCodes2[HtmlStatusCodes2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  HtmlStatusCodes2[HtmlStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HtmlStatusCodes2[HtmlStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HtmlStatusCodes2[HtmlStatusCodes2["SERVER_ERROR"] = 500] = "SERVER_ERROR";
+  HtmlStatusCodes2[HtmlStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HtmlStatusCodes2[HtmlStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HtmlStatusCodes2[HtmlStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HtmlStatusCodes2[HtmlStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HtmlStatusCodes2[HtmlStatusCodes2["NETWORK_CONNECT_TIMEOUT"] = 599] = "NETWORK_CONNECT_TIMEOUT";
+  return HtmlStatusCodes2;
+})(HtmlStatusCodes || {});
+var RsError = class _RsError extends Error {
+  err;
+  msg;
+  options;
+  status;
+  constructor(errCode, message, options) {
+    super(message);
+    this.name = "RsError";
+    this.err = errCode;
+    this.msg = message || "";
+    this.status = _RsError.htmlStatus(errCode);
+    this.options = options;
+  }
+  toJSON() {
+    return {
+      type: this.name,
+      err: this.err,
+      message: this.message,
+      msg: this.msg,
+      status: this.status ?? 500,
+      stack: this.stack ?? "",
+      options: this.options
+    };
+  }
+  static htmlStatus(code) {
+    return htmlStatusMap[code];
+  }
+  static isRsError(error) {
+    return error instanceof _RsError;
+  }
+};
+var htmlStatusMap = {
+  // 1:1 mappings to HTTP status codes
+  BAD_REQUEST: 400 /* BAD_REQUEST */,
+  UNAUTHORIZED: 401 /* UNAUTHORIZED */,
+  PAYMENT_REQUIRED: 402 /* PAYMENT_REQUIRED */,
+  FORBIDDEN: 403 /* FORBIDDEN */,
+  NOT_FOUND: 404 /* NOT_FOUND */,
+  METHOD_NOT_ALLOWED: 405 /* METHOD_NOT_ALLOWED */,
+  REQUEST_TIMEOUT: 408 /* REQUEST_TIMEOUT */,
+  CONFLICT: 409 /* CONFLICT */,
+  GONE: 410 /* GONE */,
+  PAYLOAD_TOO_LARGE: 413 /* PAYLOAD_TOO_LARGE */,
+  UNSUPPORTED_MEDIA_TYPE: 415 /* UNSUPPORTED_MEDIA_TYPE */,
+  UPGRADE_REQUIRED: 426 /* UPGRADE_REQUIRED */,
+  UNPROCESSABLE_ENTITY: 422 /* UNPROCESSABLE_ENTITY */,
+  TOO_MANY_REQUESTS: 429 /* TOO_MANY_REQUESTS */,
+  SERVER_ERROR: 500 /* SERVER_ERROR */,
+  NOT_IMPLEMENTED: 501 /* NOT_IMPLEMENTED */,
+  BAD_GATEWAY: 502 /* BAD_GATEWAY */,
+  SERVICE_UNAVAILABLE: 503 /* SERVICE_UNAVAILABLE */,
+  GATEWAY_TIMEOUT: 504 /* GATEWAY_TIMEOUT */,
+  NETWORK_CONNECT_TIMEOUT: 599 /* NETWORK_CONNECT_TIMEOUT */,
+  // Specific business errors mapped to appropriate HTTP codes
+  UNKNOWN_ERROR: 500 /* SERVER_ERROR */,
+  RATE_LIMIT_EXCEEDED: 429 /* TOO_MANY_REQUESTS */,
+  INVALID_TOKEN: 401 /* UNAUTHORIZED */,
+  INCORRECT_EMAIL_OR_PASSWORD: 401 /* UNAUTHORIZED */,
+  DUPLICATE: 409 /* CONFLICT */,
+  CONNECTION_ERROR: 504 /* GATEWAY_TIMEOUT */,
+  SCHEMA_ERROR: 500 /* SERVER_ERROR */,
+  DATABASE_ERROR: 500 /* SERVER_ERROR */
+};
+
 // src/logger/loggerConfigSchema.ts
 import { z } from "zod";
 var loggerConfigSchema = z.object({
@@ -68,6 +156,9 @@ var defaultSerializer = (error) => {
       responseData: err.response?.data
     };
   }
+  if (RsError.isRsError(error)) {
+    return error.toJSON();
+  }
   return baseSerializer(error);
 };
 var errorSerializer = (() => {
@@ -197,7 +288,7 @@ var EventManager = class {
   async fireInsertActions(data, triggerResult) {
     await Bluebird.map(
       this.actionHandlers.DATABASE_ROW_INSERT,
-      ({ callback, filter }) => {
+      async ({ callback, filter }) => {
         if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
         const insertData = {
           tableName: triggerResult.table,
@@ -205,7 +296,11 @@ var EventManager = class {
           insertObject: triggerResult.record,
           queryMetadata: data.queryMetadata
         };
-        callback(insertData, data.queryMetadata);
+        try {
+          await callback(insertData, data.queryMetadata);
+        } catch (error) {
+          logger.error(`Error firing insert action for table ${triggerResult.table}`, error);
+        }
       },
       { concurrency: 10 }
     );
@@ -213,7 +308,7 @@ var EventManager = class {
   async fireDeleteActions(data, triggerResult) {
     await Bluebird.map(
       this.actionHandlers.DATABASE_ROW_DELETE,
-      ({ callback, filter }) => {
+      async ({ callback, filter }) => {
         if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
         const deleteData = {
           tableName: triggerResult.table,
@@ -221,7 +316,11 @@ var EventManager = class {
           deletedRow: triggerResult.previousRecord,
           queryMetadata: data.queryMetadata
         };
-        callback(deleteData, data.queryMetadata);
+        try {
+          await callback(deleteData, data.queryMetadata);
+        } catch (error) {
+          logger.error(`Error firing delete action for table ${triggerResult.table}`, error);
+        }
       },
       { concurrency: 10 }
     );
@@ -229,7 +328,7 @@ var EventManager = class {
   async fireUpdateActions(data, triggerResult) {
     await Bluebird.map(
       this.actionHandlers.DATABASE_COLUMN_UPDATE,
-      ({ callback, filter }) => {
+      async ({ callback, filter }) => {
         if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
         const columnChangeData = {
           tableName: triggerResult.table,
@@ -238,7 +337,11 @@ var EventManager = class {
           oldData: triggerResult.previousRecord,
           queryMetadata: data.queryMetadata
         };
-        callback(columnChangeData, data.queryMetadata);
+        try {
+          await callback(columnChangeData, data.queryMetadata);
+        } catch (error) {
+          logger.error(`Error firing update action for table ${triggerResult.table}`, error);
+        }
       },
       { concurrency: 10 }
     );
@@ -320,83 +423,6 @@ var SqlUtils = class _SqlUtils {
   }
 };
 
-// src/restura/RsError.ts
-var HtmlStatusCodes = /* @__PURE__ */ ((HtmlStatusCodes2) => {
-  HtmlStatusCodes2[HtmlStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
-  HtmlStatusCodes2[HtmlStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
-  HtmlStatusCodes2[HtmlStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
-  HtmlStatusCodes2[HtmlStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
-  HtmlStatusCodes2[HtmlStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
-  HtmlStatusCodes2[HtmlStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
-  HtmlStatusCodes2[HtmlStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
-  HtmlStatusCodes2[HtmlStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
-  HtmlStatusCodes2[HtmlStatusCodes2["GONE"] = 410] = "GONE";
-  HtmlStatusCodes2[HtmlStatusCodes2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
-  HtmlStatusCodes2[HtmlStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
-  HtmlStatusCodes2[HtmlStatusCodes2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
-  HtmlStatusCodes2[HtmlStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
-  HtmlStatusCodes2[HtmlStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
-  HtmlStatusCodes2[HtmlStatusCodes2["SERVER_ERROR"] = 500] = "SERVER_ERROR";
-  HtmlStatusCodes2[HtmlStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
-  HtmlStatusCodes2[HtmlStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
-  HtmlStatusCodes2[HtmlStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
-  HtmlStatusCodes2[HtmlStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
-  HtmlStatusCodes2[HtmlStatusCodes2["NETWORK_CONNECT_TIMEOUT"] = 599] = "NETWORK_CONNECT_TIMEOUT";
-  return HtmlStatusCodes2;
-})(HtmlStatusCodes || {});
-var RsError = class _RsError {
-  err;
-  msg;
-  options;
-  status;
-  stack;
-  constructor(errCode, message, options) {
-    this.err = errCode;
-    this.msg = message || "";
-    this.status = _RsError.htmlStatus(errCode);
-    this.stack = new Error().stack || "";
-    this.options = options;
-  }
-  static htmlStatus(code) {
-    return htmlStatusMap[code];
-  }
-  static isRsError(error) {
-    return error instanceof _RsError;
-  }
-};
-var htmlStatusMap = {
-  // 1:1 mappings to HTTP status codes
-  BAD_REQUEST: 400 /* BAD_REQUEST */,
-  UNAUTHORIZED: 401 /* UNAUTHORIZED */,
-  PAYMENT_REQUIRED: 402 /* PAYMENT_REQUIRED */,
-  FORBIDDEN: 403 /* FORBIDDEN */,
-  NOT_FOUND: 404 /* NOT_FOUND */,
-  METHOD_NOT_ALLOWED: 405 /* METHOD_NOT_ALLOWED */,
-  REQUEST_TIMEOUT: 408 /* REQUEST_TIMEOUT */,
-  CONFLICT: 409 /* CONFLICT */,
-  GONE: 410 /* GONE */,
-  PAYLOAD_TOO_LARGE: 413 /* PAYLOAD_TOO_LARGE */,
-  UNSUPPORTED_MEDIA_TYPE: 415 /* UNSUPPORTED_MEDIA_TYPE */,
-  UPGRADE_REQUIRED: 426 /* UPGRADE_REQUIRED */,
-  UNPROCESSABLE_ENTITY: 422 /* UNPROCESSABLE_ENTITY */,
-  TOO_MANY_REQUESTS: 429 /* TOO_MANY_REQUESTS */,
-  SERVER_ERROR: 500 /* SERVER_ERROR */,
-  NOT_IMPLEMENTED: 501 /* NOT_IMPLEMENTED */,
-  BAD_GATEWAY: 502 /* BAD_GATEWAY */,
-  SERVICE_UNAVAILABLE: 503 /* SERVICE_UNAVAILABLE */,
-  GATEWAY_TIMEOUT: 504 /* GATEWAY_TIMEOUT */,
-  NETWORK_CONNECT_TIMEOUT: 599 /* NETWORK_CONNECT_TIMEOUT */,
-  // Specific business errors mapped to appropriate HTTP codes
-  UNKNOWN_ERROR: 500 /* SERVER_ERROR */,
-  RATE_LIMIT_EXCEEDED: 429 /* TOO_MANY_REQUESTS */,
-  INVALID_TOKEN: 401 /* UNAUTHORIZED */,
-  INCORRECT_EMAIL_OR_PASSWORD: 401 /* UNAUTHORIZED */,
-  DUPLICATE: 409 /* CONFLICT */,
-  CONNECTION_ERROR: 504 /* GATEWAY_TIMEOUT */,
-  SCHEMA_ERROR: 500 /* SERVER_ERROR */,
-  DATABASE_ERROR: 500 /* SERVER_ERROR */
-};
-
 // src/restura/validators/ResponseValidator.ts
 var ResponseValidator = class _ResponseValidator {
   rootMap;
@@ -1092,10 +1118,10 @@ var customApiFactory_default = customApiFactory;
 import fs2 from "fs";
 import path2, { resolve } from "path";
 import tmp from "tmp";
-import * as TJS from "typescript-json-schema";
+import { createGenerator } from "ts-json-schema-generator";
 
 // src/restura/generators/schemaGeneratorUtils.ts
-function buildRouteSchema(requestParams) {
+function buildRouteSchema(routeKey, requestParams) {
   const properties = {};
   const required = [];
   for (const param of requestParams) {
@@ -1105,13 +1131,19 @@ function buildRouteSchema(requestParams) {
     const propertySchema = buildPropertySchemaFromRequest(param);
     properties[param.name] = propertySchema;
   }
-  return {
+  const schemaDefinition = {
     type: "object",
     properties,
     ...required.length > 0 && { required },
-    // Only include if not empty
     additionalProperties: false
   };
+  return {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $ref: `#/definitions/${routeKey}`,
+    definitions: {
+      [routeKey]: schemaDefinition
+    }
+  };
 }
 function buildPropertySchemaFromRequest(param) {
   const propertySchema = {};
@@ -1215,28 +1247,31 @@ function customTypeValidationGenerator(currentSchema, ignoreGeneratedTypes = fal
   }).filter(Boolean);
   if (!customInterfaceNames) return {};
   const temporaryFile = tmp.fileSync({ mode: 420, prefix: "prefix-", postfix: ".ts" });
-  fs2.writeFileSync(temporaryFile.name, currentSchema.customTypes.join("\n"));
-  const compilerOptions = {
-    strictNullChecks: true,
-    skipLibCheck: true
-    // Needed if we are processing ES modules
+  const additionalImports = ignoreGeneratedTypes ? "" : [
+    `/// <reference path="${toForwardSlashPath(path2.join(restura.resturaConfig.generatedTypesPath, "restura.d.ts"))}" />`,
+    `/// <reference path="${toForwardSlashPath(path2.join(restura.resturaConfig.generatedTypesPath, "models.d.ts"))}" />`,
+    `/// <reference path="${toForwardSlashPath(path2.join(restura.resturaConfig.generatedTypesPath, "api.d.ts"))}" />`
+  ].join("\n") + "\n";
+  const typesWithExport = currentSchema.customTypes.map((type) => {
+    if (!type.trim().startsWith("export ")) {
+      return "export " + type;
+    }
+    return type;
+  });
+  fs2.writeFileSync(temporaryFile.name, additionalImports + typesWithExport.join("\n"));
+  const config3 = {
+    path: resolve(temporaryFile.name),
+    tsconfig: path2.join(process.cwd(), "tsconfig.json"),
+    skipTypeCheck: true
   };
-  const program = TJS.getProgramFromFiles(
-    [
-      resolve(temporaryFile.name),
-      ...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
-  );
+  const generator = createGenerator(config3);
   customInterfaceNames.forEach((item) => {
-    const ddlSchema = TJS.generateSchema(program, item, {
-      required: true
-    });
-    schemaObject[item] = ddlSchema || {};
+    try {
+      const ddlSchema = generator.createSchema(item);
+      schemaObject[item] = ddlSchema || {};
+    } catch (error) {
+      logger.error("Failed to generate schema for custom type: " + item, error);
+    }
   });
   temporaryFile.removeCallback();
   for (const endpoint of currentSchema.endpoints) {
@@ -1244,11 +1279,14 @@ function customTypeValidationGenerator(currentSchema, ignoreGeneratedTypes = fal
       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);
+      schemaObject[routeKey] = buildRouteSchema(routeKey, route.request);
     }
   }
   return schemaObject;
 }
+function toForwardSlashPath(path5) {
+  return path5.replaceAll("\\", "/");
+}
 
 // src/restura/generators/standardTypeValidationGenerator.ts
 function standardTypeValidationGenerator(currentSchema) {
@@ -1259,12 +1297,18 @@ function standardTypeValidationGenerator(currentSchema) {
       const routeKey = `${route.method}:${route.path}`;
       if (!route.request || route.request.length === 0) {
         schemaObject[routeKey] = {
-          type: "object",
-          properties: {},
-          additionalProperties: false
+          $schema: "http://json-schema.org/draft-07/schema#",
+          $ref: `#/definitions/${routeKey}`,
+          definitions: {
+            [routeKey]: {
+              type: "object",
+              properties: {},
+              additionalProperties: false
+            }
+          }
         };
       } else {
-        schemaObject[routeKey] = buildRouteSchema(route.request);
+        schemaObject[routeKey] = buildRouteSchema(routeKey, route.request);
       }
     }
   }
@@ -1658,31 +1702,81 @@ async function isSchemaValid(schemaToCheck) {
 
 // src/restura/validators/requestValidator.ts
 import jsonschema from "jsonschema";
+function deepResolveSchemaRefs(schema, definitions, seen = /* @__PURE__ */ new Set()) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  if ("$ref" in schema && typeof schema.$ref === "string") {
+    const refPath = schema.$ref;
+    if (refPath.startsWith("#/definitions/") && definitions) {
+      const defName = refPath.substring("#/definitions/".length);
+      if (seen.has(defName)) {
+        return { type: "object", properties: {} };
+      }
+      const resolved = definitions[defName];
+      if (resolved) {
+        seen.add(defName);
+        return deepResolveSchemaRefs(resolved, definitions, seen);
+      }
+    }
+    return schema;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "definitions") {
+      continue;
+    }
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        result[key] = value.map(
+          (item) => typeof item === "object" ? deepResolveSchemaRefs(item, definitions, new Set(seen)) : item
+        );
+      } else {
+        result[key] = deepResolveSchemaRefs(value, definitions, new Set(seen));
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function resolveSchemaRef(schema, definitions) {
+  return deepResolveSchemaRefs(schema, definitions);
+}
 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") {
+  const routeKey = `${routeData.method}:${routeData.path}`;
+  const isCustom = routeData.type === "CUSTOM_ONE" || routeData.type === "CUSTOM_ARRAY" || routeData.type === "CUSTOM_PAGED";
+  const isStandard = routeData.type === "ONE" || routeData.type === "ARRAY" || routeData.type === "PAGED";
+  if (!isStandard && !isCustom) {
+    throw new RsError("BAD_REQUEST", `Invalid route type: ${routeData.type}`);
+  }
+  if (isCustom) {
     if (!routeData.responseType) throw new RsError("BAD_REQUEST", `No response type defined for custom request.`);
     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
-    };
-  } else {
-    throw new RsError("BAD_REQUEST", `Invalid route type: ${routeData.type}`);
   }
+  const schemaKey = isCustom ? routeData.requestType || routeKey : routeKey;
+  if (!schemaKey) throw new RsError("BAD_REQUEST", `No schema key defined for request: ${routeKey}.`);
+  const schemaDictionary = isCustom ? customValidationSchema : standardValidationSchema;
+  const schemaRoot = schemaDictionary[schemaKey];
+  if (!schemaRoot) {
+    const requestType = isCustom ? "custom" : "standard";
+    throw new RsError("BAD_REQUEST", `No schema found for ${requestType} request: ${schemaKey}.`);
+  }
+  const schemaForValidation = schemaRoot;
+  const schemaDefinitions = schemaRoot.definitions;
+  const rawInterface = schemaRoot.definitions[schemaKey];
+  const schemaForCoercion = isCustom ? resolveSchemaRef(rawInterface, schemaDefinitions) : rawInterface;
   const requestData = getRequestData(req, schemaForCoercion);
   req.data = requestData;
   const validator = new jsonschema.Validator();
-  const executeValidation = validator.validate(req.data, schemaForCoercion);
+  if (schemaDefinitions) {
+    for (const [defName, defSchema] of Object.entries(schemaDefinitions)) {
+      validator.addSchema(defSchema, `/definitions/${defName}`);
+    }
+  }
+  const resolvedSchema = resolveSchemaRef(schemaForValidation, schemaDefinitions);
+  const executeValidation = validator.validate(req.data, resolvedSchema);
   if (!executeValidation.valid) {
     const errorMessages = executeValidation.errors.map((err) => {
       const property = err.property.replace("instance.", "");
@@ -1802,7 +1896,6 @@ import pg from "pg";
 
 // src/restura/sql/PsqlConnection.ts
 import crypto from "crypto";
-import format2 from "pg-format";
 import { format as sqlFormat } from "sql-formatter";
 import { z as z5 } from "zod";
 
@@ -1831,15 +1924,25 @@ function questionMarksToOrderedParams(query) {
     return char;
   });
 }
-function insertObjectQuery(table, obj) {
+function insertObjectQuery(table, obj, options) {
+  const { customSelect } = options ?? {};
   const keys = Object.keys(obj);
   const params = Object.values(obj);
   const columns = keys.map((column) => escapeColumnName(column)).join(", ");
   const values = params.map((value) => SQL`${value}`).join(", ");
   let query = `
-INSERT INTO "${table}" (${columns})
-                 VALUES (${values})
-                 RETURNING *`;
+		INSERT INTO "${table}" (${columns})
+		VALUES (${values})
+		RETURNING *`;
+  if (customSelect) {
+    query = `
+		WITH inserted AS (
+			INSERT INTO "${table}" (${columns})
+			VALUES (${values})
+			RETURNING *
+		)
+		${customSelect}`;
+  }
   query = query.replace(/'(\?)'/g, "?");
   return query;
 }
@@ -1877,6 +1980,13 @@ function SQL(strings, ...values) {
   });
   return query;
 }
+function toSqlLiteral(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (Array.isArray(value)) return `ARRAY[${value.map((v) => toSqlLiteral(v)).join(", ")}]`;
+  return format.literal(value);
+}
 
 // src/restura/sql/PsqlConnection.ts
 var PsqlConnection = class {
@@ -1955,21 +2065,11 @@ var PsqlConnection = class {
   }
   logSqlStatement(query, options, queryMetadata, startTime, prefix = "") {
     if (logger.level !== "trace" && logger.level !== "silly") return;
-    let sqlStatement = "";
-    if (options.length === 0) {
-      sqlStatement = query;
-    } else {
-      sqlStatement = query.replace(/\$\d+/g, (match) => {
-        const paramIndex = parseInt(match.substring(1)) - 1;
-        if (paramIndex < 0 || paramIndex >= options.length) {
-          return "INVALID_PARAM_INDEX";
-        }
-        const value = options[paramIndex];
-        if (typeof value === "number") return value.toString();
-        if (typeof value === "boolean") return value.toString();
-        return format2.literal(value);
-      });
-    }
+    const sqlStatement = query.replace(/\$(\d+)/g, (_, num) => {
+      const paramIndex = parseInt(num) - 1;
+      if (paramIndex >= options.length) return "INVALID_PARAM_INDEX";
+      return toSqlLiteral(options[paramIndex]);
+    });
     const formattedSql = sqlFormat(sqlStatement, {
       language: "postgresql",
       linesBetweenQueries: 2,
@@ -2148,124 +2248,279 @@ 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');
+var initializers = `
+    // Quotes a SQL identifier (column/table name) with double quotes, escaping any embedded quotes
+    function quoteSqlIdentity(value) {
+        return '"' + value.replace(/"/g, '""') + '"';
+    }
+
+    // Unescape special characters in values: \\, -> , | \\| -> | | \\\\ -> \\
+    function unescapeValue(str) {
+        var result = '';
+        for (var i = 0; i < str.length; i++) {
+            if (str[i] === '\\\\' && i + 1 < str.length) {
+                var next = str[i + 1];
+                if (next === ',' || next === '|' || next === '\\\\') {
+                    result += next;
+                    i++;
+                } else {
+                    result += str[i];
+                }
+            } else {
+                result += str[i];
+            }
+        }
+        return result;
+    }
+
+    // Split pipe-separated values respecting escaped pipes
+    function splitPipeValues(str) {
+        var values = [];
+        var current = '';
+        for (var i = 0; i < str.length; i++) {
+            if (str[i] === '\\\\' && i + 1 < str.length && str[i + 1] === '|') {
+                current += '|';
+                i++;
+            } else if (str[i] === '|') {
+                values.push(unescapeValue(current));
+                current = '';
             } else {
-                // temp.push(quoteIdent(value[i]));
+                current += str[i];
             }
         }
-        return temp.toString();
-    } else if (value === Object(value)) {
-        throw new Error('SQL identifier cannot be an object');
+        if (current.length > 0) {
+            values.push(unescapeValue(current));
+        }
+        return values;
     }
 
-    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 = '"';
+    // Build SQL IN clause from pipe-separated values
+    function buildInClause(column, rawValue) {
+        var values = splitPipeValues(rawValue);
+        var literals = values.map(function(v) { return formatValue(v); });
+        return column + ' IN (' + literals.join(', ') + ')';
+    }
 
-    for (var i = 0; i < ident.length; i++) {
-        var c = ident[i];
-        if (c === '"') {
-            quoted += c + c;
-        } else {
-            quoted += c;
+    // Check if a value is numeric and format appropriately
+    function formatValue(value) {
+        // Check if the value is a valid number (integer or decimal)
+        if (/^-?\\d+(\\.\\d+)?$/.test(value)) {
+            return value; // Return as-is without quotes
         }
+        return format.literal(value);
     }
 
-    quoted += '"';
+    // Format a value with optional type cast
+    function formatValueWithCast(rawValue, cast) {
+        var formatted = formatValue(unescapeValue(rawValue));
+        return cast ? formatted + '::' + cast : formatted;
+    }
 
-    return quoted;
-};
+    // Build SQL IN clause from pipe-separated values with optional cast
+    function buildInClauseWithCast(column, rawValue, cast) {
+        var values = splitPipeValues(rawValue);
+        var literals = values.map(function(v) {
+            var formatted = formatValue(v);
+            return cast ? formatted + '::' + cast : formatted;
+        });
+        return column + ' IN (' + literals.join(', ') + ')';
+    }
+`;
+var entryGrammar = `
+{
+    ${initializers}
 }
 
-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)}\`})\`;}
+Start 
+    = sql:StartOld { return { sql: sql, usedOldSyntax: true }; }
+    / sql:StartNew { return { sql: sql, usedOldSyntax: false }; }
+`;
+var oldGrammar = `
+StartOld
+    = OldExpressionList
+_
+    = [ \\t\\r\\n]*  // Matches spaces, tabs, and line breaks
+
+OldExpressionList
+    = leftExpression:OldExpression _ operator:OldOperator _ rightExpression:OldExpressionList 
+        { return \`\${leftExpression} \${operator} \${rightExpression}\`;}
+    / OldExpression
+
+OldExpression
+    = negate:OldNegate? _ "(" _ "column" _ ":"  column:OldColumn _ ","? _ value:OldValue? ","? _ type:OldType? _ ")"_
+        {return \`\${negate? " NOT " : ""}(\${type ? type(column, value) : (value == null ? \`\${column} IS NULL\` : \`\${column} = \${formatValue(value)}\`)})\`;}
     /
-    negate:negate?"("expression:expressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
-
-negate = "!"
-    
-operator = "and"i / "or"i
+    negate:OldNegate?"("expression:OldExpressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
 
-	   
-column = first:text rest:("." text)* { 
-    const partsArray = [first];
-    if (rest && rest.length > 0) {
-        partsArray.push(...rest.map(item => item[1]));
-    }
+OldNegate
+    = "!"
     
-    if (partsArray.length > 3) {
-        throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
-    }
-    
-    if (partsArray.length === 1) {
-        return quoteSqlIdentity(partsArray[0]);
-    }
-    const tableName = quoteSqlIdentity(partsArray[0]);
-    
-    // If we only have two parts (table.column), use regular dot notation
-    if (partsArray.length === 2) {
-        return tableName + "." + quoteSqlIdentity(partsArray[1]);
+OldOperator
+    = "and"i / "or"i
+
+OldColumn
+    = first:OldColumnPart rest:("." OldColumnPart)* { 
+        const partsArray = [first];
+        if (rest && rest.length > 0) {
+            partsArray.push(...rest.map(item => item[1]));
+        }
+        
+        if (partsArray.length > 3) {
+            throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
+        }
+        
+        if (partsArray.length === 1) {
+            return quoteSqlIdentity(partsArray[0]);
+        }
+        const tableName = quoteSqlIdentity(partsArray[0]);
+        
+        // If we only have two parts (table.column), use regular dot notation
+        if (partsArray.length === 2) {
+            return tableName + "." + quoteSqlIdentity(partsArray[1]);
+        }
+        
+        // For JSON paths (more than 2 parts), first part is a column, last part uses ->>
+        const jsonColumn = quoteSqlIdentity(partsArray[1]);
+        const lastPart = partsArray[partsArray.length - 1];
+        const escapedLast = lastPart.replace(/'/g, "''");
+        const result = tableName + "." + jsonColumn + "->>'" + escapedLast + "'";
+        return result;
     }
-    
-    // For JSON paths (more than 2 parts), first part is a column, last part uses ->>
-    const jsonColumn = quoteSqlIdentity(partsArray[1]);
-    const lastPart = partsArray[partsArray.length - 1];
-    const result = tableName + "." + jsonColumn + "->>'" + lastPart + "'";
-    return result;
-}
-
-text = text:[a-z0-9 \\t\\r\\n\\-_:@']i+ { return text.join(""); }
 
+OldColumnPart
+    = 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}::text ILIKE '\${format.literal(value).slice(1,-1)}%'\`; } } /
-    text:"endsWith"  { return function(column, value) { return \`\${column}::text ILIKE '%\${format.literal(value).slice(1,-1)}'\`; } } /
-    text:"contains" { return function(column, value) { return \`\${column}::text 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})\`; } } 
+OldText
+    = text:[a-z0-9 \\t\\r\\n\\-_:@'.]i+ {
+        return text.join(""); 
+    }
 
-value = "value" _ ":" value:text { return value; }
+OldType
+    = "type" _ ":" _ type:OldTypeString {
+        return type; 
+    }
 
+OldTypeString
+    = 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} = \${formatValue(value)}\`; } }
+    / text:"greaterThanEqual" { return function(column, value) { return \`\${column} >= \${formatValue(value)}\`; } }
+    / text:"greaterThan" { return function(column, value) { return \`\${column} > \${formatValue(value)}\`; } }
+    / text:"lessThanEqual" { return function(column, value) { return \`\${column} <= \${formatValue(value)}\`; } }
+    / text:"lessThan" { return function(column, value) { return \`\${column} < \${formatValue(value)}\`; } }
+    / text:"isNull"   { return function(column, value) { return \`\${column} IS NULL\`; } }
 
+OldValue
+    = "value" _ ":" value:OldText {
+        return value; 
+    }
 `;
-var filterPsqlParser = peg.generate(filterSqlGrammar, {
+var newGrammar = `
+StartNew
+    = ExpressionList
+
+ExpressionList
+    = left:Expression _ op:("and"i / "or"i) _ right:ExpressionList
+        { return left + ' ' + op.toUpperCase() + ' ' + right; }
+    / Expression
+
+Expression
+    = negate:"!"? _ "(" _ inner:SimpleExprList _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + inner + ')'; }
+    / SimpleExpr
+
+SimpleExprList
+    = left:SimpleExpr _ op:("and"i / "or"i) _ right:SimpleExprList
+        { return left + ' ' + op.toUpperCase() + ' ' + right; }
+    / SimpleExpr
+
+SimpleExpr
+    = negate:"!"? _ "(" _ col:Column _ "," _ op:OperatorWithValue _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + op(col) + ')'; }
+    / negate:"!"? _ "(" _ col:Column _ "," _ op:NullOperator _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + op(col) + ')'; }
+    / negate:"!"? _ "(" _ col:Column _ "," _ val:CastedValue _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + col + ' = ' + formatValueWithCast(val.value, val.cast) + ')'; }
+
+Column
+    = first:ColPart rest:("." ColPart)* {
+        const partsArray = [first];
+        if (rest && rest.length > 0) {
+            partsArray.push(...rest.map(item => item[1]));
+        }
+        
+        if (partsArray.length > 3) {
+            throw new SyntaxError('Column path cannot have more than 3 parts (table.column.jsonField)');
+        }
+        
+        if (partsArray.length === 1) {
+            return quoteSqlIdentity(partsArray[0]);
+        }
+        const tableName = quoteSqlIdentity(partsArray[0]);
+        
+        if (partsArray.length === 2) {
+            return tableName + '.' + quoteSqlIdentity(partsArray[1]);
+        }
+        
+        const jsonColumn = quoteSqlIdentity(partsArray[1]);
+        const lastPart = partsArray[partsArray.length - 1];
+        const escapedLast = lastPart.replace(/'/g, "''");
+        return tableName + '.' + jsonColumn + "->>'" + escapedLast + "'";
+    }
+
+ColPart
+    = chars:[a-zA-Z0-9_]+ { return chars.join(''); }
+
+NullOperator
+    = "notnull"i { return function(col) { return col + ' IS NOT NULL'; }; }
+    / "null"i { return function(col) { return col + ' IS NULL'; }; }
+
+OperatorWithValue
+    = "in"i _ "," _ val:CastedValueWithPipes { return function(col) { return buildInClauseWithCast(col, val.value, val.cast); }; }
+    / "ne"i _ "," _ val:CastedValue { return function(col) { return col + ' <> ' + formatValueWithCast(val.value, val.cast); }; }
+    / "gte"i _ "," _ val:CastedValue { return function(col) { return col + ' >= ' + formatValueWithCast(val.value, val.cast); }; }
+    / "gt"i _ "," _ val:CastedValue { return function(col) { return col + ' > ' + formatValueWithCast(val.value, val.cast); }; }
+    / "lte"i _ "," _ val:CastedValue { return function(col) { return col + ' <= ' + formatValueWithCast(val.value, val.cast); }; }
+    / "lt"i _ "," _ val:CastedValue { return function(col) { return col + ' < ' + formatValueWithCast(val.value, val.cast); }; }
+    / "has"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value) + '%'); return col + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
+    / "sw"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal(unescapeValue(val.value) + '%'); return col + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
+    / "ew"i _ "," _ val:CastedValue { return function(col) { var formatted = format.literal('%' + unescapeValue(val.value)); return col + ' ILIKE ' + (val.cast ? formatted + '::' + val.cast : formatted); }; }
+
+CastedValue
+    = val:Value cast:TypeCast? { return { value: val, cast: cast }; }
+
+CastedValueWithPipes
+    = val:ValueWithPipes cast:TypeCast? { return { value: val, cast: cast }; }
+
+TypeCast
+    = "::" type:("timestamptz"i / "timestamp"i / "boolean"i / "numeric"i / "bigint"i / "text"i / "date"i / "int"i)
+        { return type.toLowerCase(); }
+
+Value
+    = chars:ValueChar+ { return chars.join(''); }
+
+ValueChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [^,()\\\\|:]
+    / c:":" !":"  { return c; }
+
+ValueWithPipes
+    = chars:ValueWithPipesChar+ { return chars.join(''); }
+
+ValueWithPipesChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [^,()\\\\:]
+    / c:":" !":"  { return c; }
+`;
+var fullGrammar = entryGrammar + oldGrammar + newGrammar;
+var filterPsqlParser = peg.generate(fullGrammar, {
   format: "commonjs",
   dependencies: { format: "pg-format" }
 });
@@ -2872,7 +3127,13 @@ DELETE FROM "${routeData.table}" ${joinStatement} ${whereClause}`;
           throw new RsError("SCHEMA_ERROR", `Invalid route keyword in route ${routeData.name}`);
         return data[requestParam.name]?.toString() || "";
       });
-      statement = filterPsqlParser_default.parse(statement);
+      const parseResult = filterPsqlParser_default.parse(statement);
+      if (parseResult.usedOldSyntax) {
+        logger.warn(
+          `Deprecated filter syntax detected in route "${routeData.name}" (${routeData.path}). Please migrate to the new filter syntax.`
+        );
+      }
+      statement = parseResult.sql;
       if (whereClause.startsWith("WHERE")) {
         whereClause += ` AND (${statement})
 `;
@@ -3590,6 +3851,7 @@ export {
   restura,
   resturaGlobalTypesGenerator,
   resturaSchema,
+  toSqlLiteral,
   updateObjectQuery
 };
 //# sourceMappingURL=index.js.map