search-input-query-parser 0.5.1 → 0.6.0

package/dist/cjs/search-query-to-ilike-sql.js

@@ -86,6 +86,27 @@ const fieldValueToSql = (field, value, state) => {
     // Rest of the function remains the same...
     switch (schema === null || schema === void 0 ? void 0 : schema.type) {
         case "date":
+            // Handle year format (YYYY)
+            if (/^\d{4}$/.test(cleanedValue)) {
+                const year = cleanedValue;
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+                ];
+            }
+            // Handle year-month format (YYYY-MM)
+            if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+                const [year, month] = cleanedValue.split('-');
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+                ];
+            }
             return [
                 `${field} = ${paramName}`,
                 addValue(newState, cleanedValue),
@@ -120,10 +141,36 @@ const rangeToSql = (field, operator, value, value2, state) => {
         ];
     }
     const [paramName, newState] = nextParam(state);
-    const val = isDateField ? value : Number(value);
+    let val = value;
+    // Handle date shorthand formats in comparison operators
+    if (isDateField) {
+        // Year format (YYYY)
+        if (/^\d{4}$/.test(value)) {
+            if (operator === ">" || operator === ">=") {
+                val = `${value}-01-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                val = `${value}-12-31`;
+            }
+        }
+        // Month format (YYYY-MM)
+        else if (/^\d{4}-\d{2}$/.test(value)) {
+            const [year, month] = value.split('-');
+            if (operator === ">" || operator === ">=") {
+                val = `${year}-${month}-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                val = `${year}-${month}-${lastDay}`;
+            }
+        }
+    }
+    else {
+        val = value; // Keep as string, will be converted to number later
+    }
     return [
         `${field} ${operator} ${paramName}`,
-        addValue(newState, val),
+        addValue(newState, isDateField ? val : Number(val)),
     ];
 };
 const inExpressionToSql = (field, values, state) => {

package/dist/cjs/search-query-to-paradedb-sql.js

@@ -109,6 +109,27 @@ const fieldValueToSql = (field, value, state) => {
     const baseValue = hasWildcard ? cleanedValue.slice(0, -1) : cleanedValue;
     switch (schema === null || schema === void 0 ? void 0 : schema.type) {
         case "date": {
+            // Handle year format (YYYY)
+            if (/^\d{4}$/.test(cleanedValue)) {
+                const year = cleanedValue;
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+                    addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+                ];
+            }
+            // Handle year-month format (YYYY-MM)
+            if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+                const [year, month] = cleanedValue.split('-');
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+                    addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+                ];
+            }
             // Use parameter binding for dates
             const [dateParam, dateState] = nextParam(state);
             return [
@@ -142,11 +163,37 @@ const rangeToSql = (field, operator, value, value2, state) => {
     }
     else {
         const [paramName, newState] = nextParam(state);
+        let val = value;
+        // Handle date shorthand formats in comparison operators
+        if (isDateField) {
+            // Year format (YYYY)
+            if (/^\d{4}$/.test(value)) {
+                if (operator === ">" || operator === ">=") {
+                    val = `${value}-01-01`;
+                }
+                else if (operator === "<" || operator === "<=") {
+                    val = `${value}-12-31`;
+                }
+            }
+            // Month format (YYYY-MM)
+            else if (/^\d{4}-\d{2}$/.test(value)) {
+                const [year, month] = value.split('-');
+                if (operator === ">" || operator === ">=") {
+                    val = `${year}-${month}-01`;
+                }
+                else if (operator === "<" || operator === "<=") {
+                    const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                    val = `${year}-${month}-${lastDay}`;
+                }
+            }
+        }
+        else {
+            val = value; // Keep as string, will be converted to number later
+        }
         const rangeOp = operator.replace(">=", ">=").replace("<=", "<=");
-        const val = isDateField ? value : Number(value);
         return [
             `${field} @@@ '${rangeOp}' || ${paramName}`,
-            addValue(newState, val),
+            addValue(newState, isDateField ? val : Number(val)),
         ];
     }
 };

package/dist/cjs/search-query-to-tsvector-sql.js

@@ -78,6 +78,27 @@ const fieldValueToSql = (field, value, state) => {
     // Rest of the function remains the same...
     switch (schema === null || schema === void 0 ? void 0 : schema.type) {
         case "date":
+            // Handle year format (YYYY)
+            if (/^\d{4}$/.test(cleanedValue)) {
+                const year = cleanedValue;
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+                ];
+            }
+            // Handle year-month format (YYYY-MM)
+            if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+                const [year, month] = cleanedValue.split('-');
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+                ];
+            }
             return [
                 `${field} = ${paramName}`,
                 addValue(newState, cleanedValue),
@@ -112,10 +133,36 @@ const rangeToSql = (field, operator, value, value2, state) => {
         ];
     }
     const [paramName, newState] = nextParam(state);
-    const val = isDateField ? value : Number(value);
+    let val = value;
+    // Handle date shorthand formats in comparison operators
+    if (isDateField) {
+        // Year format (YYYY)
+        if (/^\d{4}$/.test(value)) {
+            if (operator === ">" || operator === ">=") {
+                val = `${value}-01-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                val = `${value}-12-31`;
+            }
+        }
+        // Month format (YYYY-MM)
+        else if (/^\d{4}-\d{2}$/.test(value)) {
+            const [year, month] = value.split('-');
+            if (operator === ">" || operator === ">=") {
+                val = `${year}-${month}-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                val = `${year}-${month}-${lastDay}`;
+            }
+        }
+    }
+    else {
+        val = value; // Keep as string, will be converted to number later
+    }
     return [
         `${field} ${operator} ${paramName}`,
-        addValue(newState, val),
+        addValue(newState, isDateField ? val : Number(val)),
     ];
 };
 const inExpressionToSql = (field, values, state) => {

package/dist/cjs/validate-expression-fields.js

@@ -208,6 +208,17 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                 const dateValidator = (dateStr) => {
                     if (!dateStr)
                         return true;
+                    // Check for year format (YYYY)
+                    if (/^\d{4}$/.test(dateStr)) {
+                        return true;
+                    }
+                    // Check for year-month format (YYYY-MM)
+                    if (/^\d{4}-\d{2}$/.test(dateStr)) {
+                        const [year, month] = dateStr.split('-').map(Number);
+                        // Validate month is between 1-12
+                        return month >= 1 && month <= 12;
+                    }
+                    // Check for full date format (YYYY-MM-DD)
                     if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
                         return false;
                     }
@@ -215,6 +226,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     return (!isNaN(date.getTime()) &&
                         dateStr === date.toISOString().split("T")[0]);
                 };
+                // Handle date range with shorthand formats
                 if (value.includes("..")) {
                     const [start, end] = value.split("..");
                     if (!dateValidator(start) || !dateValidator(end)) {

package/dist/esm/search-query-to-ilike-sql.js

@@ -83,6 +83,27 @@ const fieldValueToSql = (field, value, state) => {
     // Rest of the function remains the same...
     switch (schema === null || schema === void 0 ? void 0 : schema.type) {
         case "date":
+            // Handle year format (YYYY)
+            if (/^\d{4}$/.test(cleanedValue)) {
+                const year = cleanedValue;
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+                ];
+            }
+            // Handle year-month format (YYYY-MM)
+            if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+                const [year, month] = cleanedValue.split('-');
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+                ];
+            }
             return [
                 `${field} = ${paramName}`,
                 addValue(newState, cleanedValue),
@@ -117,10 +138,36 @@ const rangeToSql = (field, operator, value, value2, state) => {
         ];
     }
     const [paramName, newState] = nextParam(state);
-    const val = isDateField ? value : Number(value);
+    let val = value;
+    // Handle date shorthand formats in comparison operators
+    if (isDateField) {
+        // Year format (YYYY)
+        if (/^\d{4}$/.test(value)) {
+            if (operator === ">" || operator === ">=") {
+                val = `${value}-01-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                val = `${value}-12-31`;
+            }
+        }
+        // Month format (YYYY-MM)
+        else if (/^\d{4}-\d{2}$/.test(value)) {
+            const [year, month] = value.split('-');
+            if (operator === ">" || operator === ">=") {
+                val = `${year}-${month}-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                val = `${year}-${month}-${lastDay}`;
+            }
+        }
+    }
+    else {
+        val = value; // Keep as string, will be converted to number later
+    }
     return [
         `${field} ${operator} ${paramName}`,
-        addValue(newState, val),
+        addValue(newState, isDateField ? val : Number(val)),
     ];
 };
 const inExpressionToSql = (field, values, state) => {

package/dist/esm/search-query-to-paradedb-sql.js

@@ -106,6 +106,27 @@ const fieldValueToSql = (field, value, state) => {
     const baseValue = hasWildcard ? cleanedValue.slice(0, -1) : cleanedValue;
     switch (schema === null || schema === void 0 ? void 0 : schema.type) {
         case "date": {
+            // Handle year format (YYYY)
+            if (/^\d{4}$/.test(cleanedValue)) {
+                const year = cleanedValue;
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+                    addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+                ];
+            }
+            // Handle year-month format (YYYY-MM)
+            if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+                const [year, month] = cleanedValue.split('-');
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+                    addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+                ];
+            }
             // Use parameter binding for dates
             const [dateParam, dateState] = nextParam(state);
             return [
@@ -139,11 +160,37 @@ const rangeToSql = (field, operator, value, value2, state) => {
     }
     else {
         const [paramName, newState] = nextParam(state);
+        let val = value;
+        // Handle date shorthand formats in comparison operators
+        if (isDateField) {
+            // Year format (YYYY)
+            if (/^\d{4}$/.test(value)) {
+                if (operator === ">" || operator === ">=") {
+                    val = `${value}-01-01`;
+                }
+                else if (operator === "<" || operator === "<=") {
+                    val = `${value}-12-31`;
+                }
+            }
+            // Month format (YYYY-MM)
+            else if (/^\d{4}-\d{2}$/.test(value)) {
+                const [year, month] = value.split('-');
+                if (operator === ">" || operator === ">=") {
+                    val = `${year}-${month}-01`;
+                }
+                else if (operator === "<" || operator === "<=") {
+                    const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                    val = `${year}-${month}-${lastDay}`;
+                }
+            }
+        }
+        else {
+            val = value; // Keep as string, will be converted to number later
+        }
         const rangeOp = operator.replace(">=", ">=").replace("<=", "<=");
-        const val = isDateField ? value : Number(value);
         return [
             `${field} @@@ '${rangeOp}' || ${paramName}`,
-            addValue(newState, val),
+            addValue(newState, isDateField ? val : Number(val)),
         ];
     }
 };

package/dist/esm/search-query-to-tsvector-sql.js

@@ -75,6 +75,27 @@ const fieldValueToSql = (field, value, state) => {
     // Rest of the function remains the same...
     switch (schema === null || schema === void 0 ? void 0 : schema.type) {
         case "date":
+            // Handle year format (YYYY)
+            if (/^\d{4}$/.test(cleanedValue)) {
+                const year = cleanedValue;
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+                ];
+            }
+            // Handle year-month format (YYYY-MM)
+            if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+                const [year, month] = cleanedValue.split('-');
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                const [param1, state1] = nextParam(state);
+                const [param2, state2] = nextParam(state1);
+                return [
+                    `${field} BETWEEN ${param1} AND ${param2}`,
+                    addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+                ];
+            }
             return [
                 `${field} = ${paramName}`,
                 addValue(newState, cleanedValue),
@@ -109,10 +130,36 @@ const rangeToSql = (field, operator, value, value2, state) => {
         ];
     }
     const [paramName, newState] = nextParam(state);
-    const val = isDateField ? value : Number(value);
+    let val = value;
+    // Handle date shorthand formats in comparison operators
+    if (isDateField) {
+        // Year format (YYYY)
+        if (/^\d{4}$/.test(value)) {
+            if (operator === ">" || operator === ">=") {
+                val = `${value}-01-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                val = `${value}-12-31`;
+            }
+        }
+        // Month format (YYYY-MM)
+        else if (/^\d{4}-\d{2}$/.test(value)) {
+            const [year, month] = value.split('-');
+            if (operator === ">" || operator === ">=") {
+                val = `${year}-${month}-01`;
+            }
+            else if (operator === "<" || operator === "<=") {
+                const lastDay = new Date(Number(year), Number(month), 0).getDate();
+                val = `${year}-${month}-${lastDay}`;
+            }
+        }
+    }
+    else {
+        val = value; // Keep as string, will be converted to number later
+    }
     return [
         `${field} ${operator} ${paramName}`,
-        addValue(newState, val),
+        addValue(newState, isDateField ? val : Number(val)),
     ];
 };
 const inExpressionToSql = (field, values, state) => {

package/dist/esm/validate-expression-fields.js

@@ -205,6 +205,17 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                 const dateValidator = (dateStr) => {
                     if (!dateStr)
                         return true;
+                    // Check for year format (YYYY)
+                    if (/^\d{4}$/.test(dateStr)) {
+                        return true;
+                    }
+                    // Check for year-month format (YYYY-MM)
+                    if (/^\d{4}-\d{2}$/.test(dateStr)) {
+                        const [year, month] = dateStr.split('-').map(Number);
+                        // Validate month is between 1-12
+                        return month >= 1 && month <= 12;
+                    }
+                    // Check for full date format (YYYY-MM-DD)
                     if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
                         return false;
                     }
@@ -212,6 +223,7 @@ const validateFieldValue = (expr, allowedFields, errors, schemas) => {
                     return (!isNaN(date.getTime()) &&
                         dateStr === date.toISOString().split("T")[0]);
                 };
+                // Handle date range with shorthand formats
                 if (value.includes("..")) {
                     const [start, end] = value.split("..");
                     if (!dateValidator(start) || !dateValidator(end)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-input-query-parser",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "A parser for advanced search query syntax with field:value support",
   "keywords": [
     "search",

package/src/parser.test.ts

@@ -432,6 +432,44 @@ describe("Search Query Parser", () => {
         "date:2023-12-31..2024-01-01"
       );
     });
+
+    test("parses date shorthand formats", () => {
+      // Year shorthand
+      testSchemaQuery(
+        "date:2024",
+        "date:2024"
+      );
+      
+      // Month shorthand
+      testSchemaQuery(
+        "date:2024-02",
+        "date:2024-02"
+      );
+      
+      // Shorthand with comparison operators
+      testSchemaQuery(
+        "date:>=2024",
+        "date:>=2024"
+      );
+      
+      testSchemaQuery(
+        "date:<2024-03",
+        "date:<2024-03"
+      );
+      
+      // Multiple date shorthands in one query
+      testSchemaQuery(
+        "date:>=2024 AND date:<2025",
+        "(date:>=2024 AND date:<2025)"
+      );
+      
+      // Mix of shorthand and full date formats
+      testSchemaQuery(
+        "date:2024 OR date:2024-01-15",
+        "(date:2024 OR date:2024-01-15)"
+      );
+    });
+
     describe("Wildcard Pattern Support", () => {
       test("parses simple wildcard patterns", () => {
         testValidQuery("test*", "test*");
@@ -764,7 +802,6 @@ describe("Search Query Parser", () => {
           length: 11,
         },
       ]);
-
       testSchemaErrorQuery("date:2024-13-01..2024-12-31", [
         {
           message: "Invalid date format",
@@ -775,6 +812,48 @@ describe("Search Query Parser", () => {
       ]);
     });
 
+    test("validates date shorthand formats", () => {
+      // Invalid year format
+      testSchemaErrorQuery("date:202", [
+        {
+          message: "Invalid date format",
+          code: SearchQueryErrorCode.VALUE_DATE_FORMAT_INVALID,
+          position: 5,
+          length: 3,
+        },
+      ]);
+      
+      // Invalid month format
+      testSchemaErrorQuery("date:2024-13", [
+        {
+          message: "Invalid date format",
+          code: SearchQueryErrorCode.VALUE_DATE_FORMAT_INVALID,
+          position: 5,
+          length: 7,
+        },
+      ]);
+      
+      // Invalid month value
+      testSchemaErrorQuery("date:2024-00", [
+        {
+          message: "Invalid date format",
+          code: SearchQueryErrorCode.VALUE_DATE_FORMAT_INVALID,
+          position: 5,
+          length: 7,
+        },
+      ]);
+      
+      // Invalid comparison with shorthand
+      testSchemaErrorQuery("date:>invalid-year", [
+        {
+          message: "Invalid date format",
+          code: SearchQueryErrorCode.VALUE_DATE_FORMAT_INVALID,
+          position: 5,
+          length: 13,
+        },
+      ]);
+    });
+
     test("handles invalid boolean values", () => {
       testSchemaErrorQuery("in_stock:maybe", [
         {

package/src/search-query-to-ilike-sql.ts

@@ -148,6 +148,29 @@ const fieldValueToSql = (
   // Rest of the function remains the same...
   switch (schema?.type) {
     case "date":
+      // Handle year format (YYYY)
+      if (/^\d{4}$/.test(cleanedValue)) {
+        const year = cleanedValue;
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        return [
+          `${field} BETWEEN ${param1} AND ${param2}`,
+          addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+        ];
+      }
+      
+      // Handle year-month format (YYYY-MM)
+      if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+        const [year, month] = cleanedValue.split('-');
+        const lastDay = new Date(Number(year), Number(month), 0).getDate();
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        return [
+          `${field} BETWEEN ${param1} AND ${param2}`,
+          addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+        ];
+      }
+      
       return [
         `${field} = ${paramName}`,
         addValue(newState, cleanedValue),
@@ -194,10 +217,35 @@ const rangeToSql = (
   }
 
   const [paramName, newState] = nextParam(state);
-  const val = isDateField ? value : Number(value);
+  let val = value;
+  
+  // Handle date shorthand formats in comparison operators
+  if (isDateField) {
+    // Year format (YYYY)
+    if (/^\d{4}$/.test(value)) {
+      if (operator === ">" || operator === ">=") {
+        val = `${value}-01-01`;
+      } else if (operator === "<" || operator === "<=") {
+        val = `${value}-12-31`;
+      }
+    }
+    // Month format (YYYY-MM)
+    else if (/^\d{4}-\d{2}$/.test(value)) {
+      const [year, month] = value.split('-');
+      if (operator === ">" || operator === ">=") {
+        val = `${year}-${month}-01`;
+      } else if (operator === "<" || operator === "<=") {
+        const lastDay = new Date(Number(year), Number(month), 0).getDate();
+        val = `${year}-${month}-${lastDay}`;
+      }
+    }
+  } else {
+    val = value; // Keep as string, will be converted to number later
+  }
+  
   return [
     `${field} ${operator} ${paramName}`,
-    addValue(newState, val),
+    addValue(newState, isDateField ? val : Number(val)),
   ];
 };
 

package/src/search-query-to-paradedb-sql.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "@jest/globals";
+import { searchStringToParadeDbSql } from "./search-query-to-paradedb-sql";
+import { FieldSchema } from "./parser";
+
+describe("ParadeDB SQL Converter", () => {
+  const schemas: FieldSchema[] = [
+    { name: "title", type: "string" },
+    { name: "description", type: "string" },
+    { name: "content", type: "string" },
+    { name: "price", type: "number" },
+    { name: "date", type: "date" },
+    { name: "in_stock", type: "boolean" },
+  ];
+
+  const searchableColumns = ["title", "description", "content"];
+
+  const testParadeDBConversion = (
+    query: string,
+    expectedSql: string,
+    expectedValues: any[]
+  ) => {
+    const result = searchStringToParadeDbSql(
+      query,
+      searchableColumns,
+      schemas
+    );
+    expect(result.text).toBe(expectedSql);
+    expect(result.values).toEqual(expectedValues);
+  };
+
+  describe("ParadeDB Date Handling", () => {
+    test("handles date year shorthand format", () => {
+      testParadeDBConversion(
+        "date:2024",
+        "date @@@ '[' || $1 || ' TO ' || $2 || ']'",
+        ["2024-01-01", "2024-12-31"]
+      );
+    });
+
+    test("handles date month shorthand format", () => {
+      testParadeDBConversion(
+        "date:2024-02",
+        "date @@@ '[' || $1 || ' TO ' || $2 || ']'",
+        ["2024-02-01", "2024-02-29"] // 2024 is a leap year
+      );
+      
+      testParadeDBConversion(
+        "date:2023-04",
+        "date @@@ '[' || $1 || ' TO ' || $2 || ']'",
+        ["2023-04-01", "2023-04-30"]
+      );
+    });
+
+    test("handles date shorthand formats with comparison operators", () => {
+      testParadeDBConversion(
+        "date:>=2024 AND date:<2025",
+        "(date @@@ '>=' || $1 AND date @@@ '<' || $2)",
+        ["2024-01-01", "2025-12-31"]
+      );
+    });
+  });
+}); 

package/src/search-query-to-paradedb-sql.ts

@@ -174,6 +174,29 @@ const fieldValueToSql = (
 
   switch (schema?.type) {
     case "date": {
+      // Handle year format (YYYY)
+      if (/^\d{4}$/.test(cleanedValue)) {
+        const year = cleanedValue;
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        return [
+          `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+          addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+        ];
+      }
+      
+      // Handle year-month format (YYYY-MM)
+      if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+        const [year, month] = cleanedValue.split('-');
+        const lastDay = new Date(Number(year), Number(month), 0).getDate();
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        return [
+          `${field} @@@ '[' || ${param1} || ' TO ' || ${param2} || ']'`,
+          addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+        ];
+      }
+      
       // Use parameter binding for dates
       const [dateParam, dateState] = nextParam(state);
       return [
@@ -214,11 +237,36 @@ const rangeToSql = (
     ];
   } else {
     const [paramName, newState] = nextParam(state);
+    let val = value;
+    
+    // Handle date shorthand formats in comparison operators
+    if (isDateField) {
+      // Year format (YYYY)
+      if (/^\d{4}$/.test(value)) {
+        if (operator === ">" || operator === ">=") {
+          val = `${value}-01-01`;
+        } else if (operator === "<" || operator === "<=") {
+          val = `${value}-12-31`;
+        }
+      }
+      // Month format (YYYY-MM)
+      else if (/^\d{4}-\d{2}$/.test(value)) {
+        const [year, month] = value.split('-');
+        if (operator === ">" || operator === ">=") {
+          val = `${year}-${month}-01`;
+        } else if (operator === "<" || operator === "<=") {
+          const lastDay = new Date(Number(year), Number(month), 0).getDate();
+          val = `${year}-${month}-${lastDay}`;
+        }
+      }
+    } else {
+      val = value; // Keep as string, will be converted to number later
+    }
+    
     const rangeOp = operator.replace(">=", ">=").replace("<=", "<=");
-    const val = isDateField ? value : Number(value);
     return [
       `${field} @@@ '${rangeOp}' || ${paramName}`,
-      addValue(newState, val),
+      addValue(newState, isDateField ? val : Number(val)),
     ];
   }
 };

package/src/search-query-to-sql.test.ts

@@ -320,6 +320,36 @@ describe("Search Query to SQL Converter", () => {
       );
       testIlikeConversion("amount:<-10", "amount < $1", [-10]);
     });
+
+    test("handles date year shorthand format", () => {
+      testIlikeConversion(
+        "date:2024",
+        "date BETWEEN $1 AND $2",
+        ["2024-01-01", "2024-12-31"]
+      );
+    });
+
+    test("handles date month shorthand format", () => {
+      testIlikeConversion(
+        "date:2024-02",
+        "date BETWEEN $1 AND $2",
+        ["2024-02-01", "2024-02-29"] // 2024 is a leap year
+      );
+      
+      testIlikeConversion(
+        "date:2023-04",
+        "date BETWEEN $1 AND $2",
+        ["2023-04-01", "2023-04-30"]
+      );
+    });
+
+    test("handles date shorthand formats with comparison operators", () => {
+      testIlikeConversion(
+        "date:>=2024 AND date:<2025",
+        "(date >= $1 AND date < $2)",
+        ["2024-01-01", "2025-12-31"]
+      );
+    });
   });
 
   describe("tsvector Search Type", () => {
@@ -373,6 +403,36 @@ describe("Search Query to SQL Converter", () => {
         ["boots", "winter gear"]
       );
     });
+
+    test("handles date year shorthand format with tsvector", () => {
+      testTsvectorConversion(
+        "date:2024",
+        "date BETWEEN $1 AND $2",
+        ["2024-01-01", "2024-12-31"]
+      );
+    });
+
+    test("handles date month shorthand format with tsvector", () => {
+      testTsvectorConversion(
+        "date:2024-02",
+        "date BETWEEN $1 AND $2",
+        ["2024-02-01", "2024-02-29"] // 2024 is a leap year
+      );
+      
+      testTsvectorConversion(
+        "date:2023-04",
+        "date BETWEEN $1 AND $2",
+        ["2023-04-01", "2023-04-30"]
+      );
+    });
+
+    test("handles date shorthand formats with comparison operators with tsvector", () => {
+      testTsvectorConversion(
+        "date:>=2024 AND date:<2025",
+        "(date >= $1 AND date < $2)",
+        ["2024-01-01", "2025-12-31"]
+      );
+    });
   });
 
   describe("paradedb Search Type", () => {

package/src/search-query-to-tsvector-sql.ts

@@ -137,6 +137,29 @@ const fieldValueToSql = (
   // Rest of the function remains the same...
   switch (schema?.type) {
     case "date":
+      // Handle year format (YYYY)
+      if (/^\d{4}$/.test(cleanedValue)) {
+        const year = cleanedValue;
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        return [
+          `${field} BETWEEN ${param1} AND ${param2}`,
+          addValue(addValue(state2, `${year}-01-01`), `${year}-12-31`),
+        ];
+      }
+      
+      // Handle year-month format (YYYY-MM)
+      if (/^\d{4}-\d{2}$/.test(cleanedValue)) {
+        const [year, month] = cleanedValue.split('-');
+        const lastDay = new Date(Number(year), Number(month), 0).getDate();
+        const [param1, state1] = nextParam(state);
+        const [param2, state2] = nextParam(state1);
+        return [
+          `${field} BETWEEN ${param1} AND ${param2}`,
+          addValue(addValue(state2, `${year}-${month}-01`), `${year}-${month}-${lastDay}`),
+        ];
+      }
+      
       return [
         `${field} = ${paramName}`,
         addValue(newState, cleanedValue),
@@ -182,10 +205,35 @@ const rangeToSql = (
   }
 
   const [paramName, newState] = nextParam(state);
-  const val = isDateField ? value : Number(value);
+  let val = value;
+  
+  // Handle date shorthand formats in comparison operators
+  if (isDateField) {
+    // Year format (YYYY)
+    if (/^\d{4}$/.test(value)) {
+      if (operator === ">" || operator === ">=") {
+        val = `${value}-01-01`;
+      } else if (operator === "<" || operator === "<=") {
+        val = `${value}-12-31`;
+      }
+    }
+    // Month format (YYYY-MM)
+    else if (/^\d{4}-\d{2}$/.test(value)) {
+      const [year, month] = value.split('-');
+      if (operator === ">" || operator === ">=") {
+        val = `${year}-${month}-01`;
+      } else if (operator === "<" || operator === "<=") {
+        const lastDay = new Date(Number(year), Number(month), 0).getDate();
+        val = `${year}-${month}-${lastDay}`;
+      }
+    }
+  } else {
+    val = value; // Keep as string, will be converted to number later
+  }
+  
   return [
     `${field} ${operator} ${paramName}`,
-    addValue(newState, val),
+    addValue(newState, isDateField ? val : Number(val)),
   ];
 };
 

package/src/validate-expression-fields.ts

@@ -254,6 +254,20 @@ const validateFieldValue = (
       if (schema.type === "date") {
         const dateValidator = (dateStr: string) => {
           if (!dateStr) return true;
+          
+          // Check for year format (YYYY)
+          if (/^\d{4}$/.test(dateStr)) {
+            return true;
+          }
+          
+          // Check for year-month format (YYYY-MM)
+          if (/^\d{4}-\d{2}$/.test(dateStr)) {
+            const [year, month] = dateStr.split('-').map(Number);
+            // Validate month is between 1-12
+            return month >= 1 && month <= 12;
+          }
+          
+          // Check for full date format (YYYY-MM-DD)
           if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
             return false;
           }
@@ -264,6 +278,7 @@ const validateFieldValue = (
           );
         };
 
+        // Handle date range with shorthand formats
         if (value.includes("..")) {
           const [start, end] = value.split("..");
           if (!dateValidator(start) || !dateValidator(end)) {