@restura/core 1.6.0 → 1.7.0

package/dist/index.js

@@ -197,7 +197,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 +205,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 +217,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 +225,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 +237,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 +246,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 }
     );
@@ -1092,10 +1104,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 +1117,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 +1233,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 +1265,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 +1283,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 +1688,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 +1882,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";
 
@@ -1877,6 +1956,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 +2041,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 +2224,246 @@ 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 += '"';
-
-    return quoted;
-};
+`;
+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:OldNegate?"("expression:OldExpressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
 
-negate = "!"
-    
-operator = "and"i / "or"i
-
-	   
-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:OldText rest:("." OldText)* { 
+        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(""); }
 
+OldText
+    = 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})\`; } } 
-
-value = "value" _ ":" value:text { return value; }
+OldType
+    = "type" _ ":" _ type:OldTypeString {
+        return type; 
+    }
 
+OldTypeString
+    = 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} = \${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:Value _ ")" _
+        { return (negate ? 'NOT ' : '') + '(' + col + ' = ' + formatValue(unescapeValue(val)) + ')'; }
+
+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:ValueWithPipes { return function(col) { return buildInClause(col, val); }; }
+    / "ne"i _ "," _ val:Value { return function(col) { return col + ' <> ' + formatValue(unescapeValue(val)); }; }
+    / "gte"i _ "," _ val:Value { return function(col) { return col + ' >= ' + formatValue(unescapeValue(val)); }; }
+    / "gt"i _ "," _ val:Value { return function(col) { return col + ' > ' + formatValue(unescapeValue(val)); }; }
+    / "lte"i _ "," _ val:Value { return function(col) { return col + ' <= ' + formatValue(unescapeValue(val)); }; }
+    / "lt"i _ "," _ val:Value { return function(col) { return col + ' < ' + formatValue(unescapeValue(val)); }; }
+    / "has"i _ "," _ val:Value { return function(col) { return col + '::text ILIKE ' + format.literal('%' + unescapeValue(val) + '%'); }; }
+    / "sw"i _ "," _ val:Value { return function(col) { return col + '::text ILIKE ' + format.literal(unescapeValue(val) + '%'); }; }
+    / "ew"i _ "," _ val:Value { return function(col) { return col + '::text ILIKE ' + format.literal('%' + unescapeValue(val)); }; }
+
+Value
+    = chars:ValueChar+ { return chars.join(''); }
+
+ValueChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [^,()\\\\|]
+
+ValueWithPipes
+    = chars:ValueWithPipesChar+ { return chars.join(''); }
+
+ValueWithPipesChar
+    = "\\\\\\\\" { return '\\\\\\\\'; }
+    / "\\\\," { return '\\\\,'; }
+    / "\\\\|" { return '\\\\|'; }
+    / [^,()\\\\]
+`;
+var fullGrammar = entryGrammar + oldGrammar + newGrammar;
+var filterPsqlParser = peg.generate(fullGrammar, {
   format: "commonjs",
   dependencies: { format: "pg-format" }
 });
@@ -2872,7 +3070,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 +3794,7 @@ export {
   restura,
   resturaGlobalTypesGenerator,
   resturaSchema,
+  toSqlLiteral,
   updateObjectQuery
 };
 //# sourceMappingURL=index.js.map