wizard-ql 3.0.0 → 4.0.1

package/README.md

@@ -20,6 +20,9 @@
 
 [Demo](https://exoRift.github.io/wizard-ql)
 
+## Installation
+`npm i wizard-ql`
+
 ## Examples
 `WizardParser.parse('(rank >= 10 & role = admin) | banned')`
 
@@ -327,13 +330,13 @@ A record mapping field names to (`boolean`, `string`, `number`, `date`). The val
 > ```
 
 > [!NOTE]
-> A value will only be attempted to be parsed as a date if `'date'` is included in the field's type record.
-> If the value is a number, it will be parsed as number of milliseconds. Any non-number character will cause the value to be parsed as a string
+> A value will only be attempted to be parsed as a date if `'date'` is included in the field's type record or if the operator is exclusively a date operator.
+> According to the default date parser, if the value is a number, it will be parsed as number of milliseconds. Any non-number character will cause the value to be parsed as a string (See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/Date)
 
 The type coercion priority chain is as follows:
 `boolean` -> `date` -> `number` -> `string`
 > [!WARNING]
-> This can cause issues for numbers with leading zeros. If this is a potential problem, make sure to exclude `number` from the types and include `string`
+> This can cause issues for numbers with leading zeros. If this is a potential problem, make sure to exclude `number` from the field types and include `string`
 
 ### Regarding constraints: `validated` property
 When a field has matched either a key in `types` or a field in `restricted`, the `validated` property on the parsed condition will be true. This is due to a limitation with TypeScript's type checking.

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from './spec';
 export * from './parser';
-export { executeAsKnex } from './execute';
 export { ParseError, ConstraintError } from './errors';
 export { createDOMInput } from './dominput';

package/dist/index.js

@@ -185,14 +185,14 @@ class WizardParser {
       NOTMATCH: "≇"
     }
   };
-  static QUOTES = ["'", '"', "`"];
-  static NEGATORS = ["!"];
-  static ARRAY_DELIMITERS = [","];
-  static ARRAY_BRACKETS = [
+  static DEFAULT_QUOTES = ['"', "'", "`"];
+  static DEFAULT_NEGATORS = ["!"];
+  static DEFAULT_ARRAY_DELIMITERS = [","];
+  static DEFAULT_ARRAY_BRACKETS = [
     ["[", "]"],
     ["{", "}"]
   ];
-  static GROUP_BRACKETS = [
+  static DEFAULT_GROUP_BRACKETS = [
     ["(", ")"]
   ];
   OPERATOR_DICTIONARY;
@@ -216,6 +216,38 @@ class WizardParser {
       if (!config.dialects)
         config.dialects = WizardParser.DEFAULT_DIALECTS;
     }
+    const symbolPool = new Set;
+    config.symbols ??= {};
+    config.symbols.quotes ??= WizardParser.DEFAULT_QUOTES;
+    config.symbols.negators ??= WizardParser.DEFAULT_NEGATORS;
+    config.symbols.arrayDelimiters ??= WizardParser.DEFAULT_ARRAY_DELIMITERS;
+    config.symbols.arrayBrackets ??= WizardParser.DEFAULT_ARRAY_BRACKETS;
+    config.symbols.groupBrackets ??= WizardParser.DEFAULT_GROUP_BRACKETS;
+    for (const [opening, closing] of config.symbols.arrayBrackets) {
+      if (opening === closing)
+        throw Error(`Opening array bracket cannot be the same as closing array bracket ("${opening}")`);
+      if (symbolPool.has(opening))
+        throw Error(`Opening array bracket "${opening}" uses a symbol already defined elsewhere in the parser`);
+      if (symbolPool.has(closing))
+        throw Error(`Closing array bracket "${closing}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(opening);
+      symbolPool.add(closing);
+    }
+    for (const [opening, closing] of config.symbols.groupBrackets) {
+      if (opening === closing)
+        throw Error(`Opening group bracket cannot be the same as closing group bracket ("${opening}")`);
+      if (symbolPool.has(opening))
+        throw Error(`Opening group bracket "${opening}" uses a symbol already defined elsewhere in the parser`);
+      if (symbolPool.has(closing))
+        throw Error(`Closing group bracket "${closing}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(opening);
+      symbolPool.add(closing);
+    }
+    for (const quote of config.symbols.quotes) {
+      if (symbolPool.has(quote))
+        throw Error(`Quote "${quote}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(quote);
+    }
     this.FIELD_LIST = new Map;
     if (config.caseInsensitive) {
       if (config.types) {
@@ -230,6 +262,24 @@ class WizardParser {
     this.OPERATOR_DICTIONARY = {};
     for (const operationName in config.operators) {
       const operation = config.operators[operationName];
+      for (const symbol of symbolPool) {
+        if (operationName.includes(symbol))
+          throw Error(`Operator "${operationName}" contains symbol "${symbol}"`);
+        if (operation.aliases) {
+          for (const alias of operation.aliases) {
+            if (alias.includes(symbol))
+              throw Error(`Operator "${operationName}" alias "${alias}" contains symbol "${symbol}"`);
+          }
+        }
+        if (operation.negationName.includes(symbol))
+          throw Error(`Operator "${operation.negationName}" contains symbol "${symbol}"`);
+        if (operation.negationAliases) {
+          for (const alias of operation.negationAliases) {
+            if (alias.includes(symbol))
+              throw Error(`Operator "${operation.negationName}" alias "${alias}" contains symbol "${symbol}"`);
+          }
+        }
+      }
       const opDef = {
         name: operationName,
         type: operation.type,
@@ -263,11 +313,16 @@ class WizardParser {
         }
       }
     }
-    this.TOKEN_REGEX = new RegExp(createTokenRegexString(Object.keys(this.OPERATOR_DICTIONARY).concat(WizardParser.GROUP_BRACKETS.flat()).concat(WizardParser.ARRAY_BRACKETS.flat()).concat(WizardParser.NEGATORS).concat(WizardParser.ARRAY_DELIMITERS), WizardParser.QUOTES), "g");
-    const quoteRegexStr = createQuoteRegexString(WizardParser.QUOTES);
+    for (const negator of config.symbols.negators) {
+      if (symbolPool.has(negator))
+        throw Error(`Negator "${negator}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(negator);
+    }
+    this.TOKEN_REGEX = new RegExp(createTokenRegexString(Object.keys(this.OPERATOR_DICTIONARY).concat(config.symbols.groupBrackets.flat()).concat(config.symbols.arrayBrackets.flat()).concat(config.symbols.negators).concat(config.symbols.arrayDelimiters), config.symbols.quotes), "g");
+    const quoteRegexStr = createQuoteRegexString(config.symbols.quotes);
     this.QUOTE_REGEX = new RegExp(quoteRegexStr);
     this.QUOTE_EDGE_REGEX = new RegExp(`^${quoteRegexStr}$`);
-    this.ARRAY_DELIMITER_REGEX = new RegExp(createArrayDelimitRegexString(WizardParser.QUOTES, WizardParser.ARRAY_DELIMITERS), "g");
+    this.ARRAY_DELIMITER_REGEX = new RegExp(createArrayDelimitRegexString(config.symbols.quotes, config.symbols.arrayDelimiters), "g");
     Object.freeze(config);
   }
   static pushSanitized(array, item, index) {
@@ -293,7 +348,7 @@ class WizardParser {
     let lastMatchEnd = null;
     for (const match of matches) {
       WizardParser.pushSanitized(tokens, expression.slice(lastMatchEnd ?? 0, match.index), lastMatchEnd === null ? 0 : lastMatchEnd);
-      if (WizardParser.ARRAY_BRACKETS.some(([o]) => match[0] === o)) {
+      if (this.CONFIG.symbols.arrayBrackets.some(([o]) => match[0] === o)) {
         const startToken = {
           content: match[0],
           index: match.index
@@ -304,7 +359,7 @@ class WizardParser {
         for (const submatch of matches) {
           if (match[0] === submatch[0] || match[0] === submatch[0])
             ++subopenings;
-          if (WizardParser.ARRAY_BRACKETS.some(([o, c]) => match[0] === o && submatch[0] === c)) {
+          if (this.CONFIG.symbols.arrayBrackets.some(([o, c]) => match[0] === o && submatch[0] === c)) {
             if (subopenings)
               --subopenings;
             else {
@@ -419,7 +474,7 @@ class WizardParser {
       throw new Error("operator");
     if (!fieldHits)
       throw new Error("field");
-    throw new Error("operator");
+    throw new Error("disagreement");
   }
   validateCondition(condition, valueIsImplicit, ctx) {
     let validated = false;
@@ -505,7 +560,9 @@ class WizardParser {
           case "operator":
             throw new ConstraintError(`Value "${condition.value.toString()}" not allowed for operation "${condition.operation}" which only allows for "${operationType}" type`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
           case "field":
-            throw new ConstraintError(`Value "${condition.value.toString()}" includes a type not permitted for field "${condition.field}". Allowed types: ${(fieldTypes ?? opTypes).join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+            throw new ConstraintError(`Value "${condition.value.toString()}" only has types not permitted for field "${condition.field}". Allowed types: ${(fieldTypes ?? opTypes).join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          case "disagreement":
+            throw new ConstraintError(`Value "${condition.value.toString()}" using operation "${condition.operation}" cannot be coerced into a valid type for "${condition.field}". Allowed field types: ${(fieldTypes ?? ["ALL"]).join(", ")}; Allowed operator types: ${opTypes.join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
         }
       }
     }
@@ -579,11 +636,11 @@ class WizardParser {
     };
     for (let t = 0;t < tokens.length; ++t) {
       const token = tokens[t];
-      if (WizardParser.GROUP_BRACKETS.some(([, c]) => token.content === c))
+      if (this.CONFIG.symbols.groupBrackets.some(([, c]) => token.content === c))
         throw new ParseError("Unexpected closing parenthesis", tokens, token, _offset + t);
-      if (WizardParser.ARRAY_BRACKETS.some(([, c]) => token.content === c))
+      if (this.CONFIG.symbols.arrayBrackets.some(([, c]) => token.content === c))
         throw new ParseError("Unexpected closing bracket/brace", tokens, token, _offset + t);
-      const paren = WizardParser.GROUP_BRACKETS.find(([o]) => token.content === o);
+      const paren = this.CONFIG.symbols.groupBrackets.find(([o]) => token.content === o);
       if (paren) {
         if (field || comparisonOperation || value)
           throw new ParseError("Tried to open a group during an operation", tokens, token, _offset + t);
@@ -665,9 +722,9 @@ class WizardParser {
         }
         continue;
       }
-      if (WizardParser.NEGATORS.includes(token.content)) {
+      if (this.CONFIG.symbols.negators.includes(token.content)) {
         const nextToken = tokens[t + 1];
-        const nextParen = WizardParser.GROUP_BRACKETS.find(([o]) => nextToken?.content === o);
+        const nextParen = this.CONFIG.symbols.groupBrackets.find(([o]) => nextToken?.content === o);
         if (nextParen) {
           resolveCondition({
             tokens,
@@ -716,7 +773,7 @@ class WizardParser {
           throw new ParseError("Expected a comparison operator", tokens, field.token, field.index, token, _offset + t);
       }
       if (!field) {
-        if (WizardParser.NEGATORS.includes(token.content)) {
+        if (this.CONFIG.symbols.negators.includes(token.content)) {
           if (!this.CONFIG.implicitCondition)
             throw new ParseError("Could not attempt a negative implicit condition as one is not defined in the config", tokens, token, _offset + t);
           const nextToken = tokens[t + 1];
@@ -759,7 +816,7 @@ class WizardParser {
         continue;
       }
       if (!value) {
-        const bracket = WizardParser.ARRAY_BRACKETS.find(([o]) => token.content === o);
+        const bracket = this.CONFIG.symbols.arrayBrackets.find(([o]) => token.content === o);
         if (bracket) {
           const closingIndex = WizardParser.getClosingIndex(tokens, t, bracket[0], bracket[1]);
           if (closingIndex === -1)
@@ -792,7 +849,7 @@ class WizardParser {
           };
           for (let ct = 0;ct < arrayContents.length; ++ct) {
             const contentToken = arrayContents[ct];
-            if (WizardParser.ARRAY_DELIMITERS.includes(contentToken.content)) {
+            if (this.CONFIG.symbols.arrayDelimiters.includes(contentToken.content)) {
               if (!workingEntry)
                 throw new ParseError("Unexpected blank entry in array", tokens, contentToken, _offset + t + ct);
               resolveEntry(contentToken, _offset + t + ct);
@@ -867,20 +924,21 @@ class WizardParser {
     return this._parse(tokens, 0);
   }
   addQuotesIfNecessary(value) {
+    const QUOTE = this.CONFIG.symbols.quotes[0];
     if (value instanceof Date) {
-      return this.CONFIG.dateSerializer ? this.CONFIG.dateSerializer(value) : value.toISOString();
+      return this.CONFIG.dateSerializer ? this.CONFIG.dateSerializer(value) : QUOTE + value.toISOString() + QUOTE;
     }
     if (typeof value !== "string")
       return value.toString();
     if (value === "true")
-      return '"true"';
+      return `${QUOTE}true${QUOTE}`;
     if (value === "false")
-      return '"false"';
+      return `${QUOTE}false${QUOTE}`;
     if (!isNaN(Number(value)))
-      return `"${value}"`;
+      return `${QUOTE}${value}${QUOTE}`;
     const escaped = value.replaceAll("\\", "\\\\");
     if (new RegExp(this.TOKEN_REGEX, "gi").test(escaped))
-      return `"${escaped.replaceAll('"', "\\\"")}"`;
+      return `${QUOTE}${escaped.replaceAll(QUOTE, `\\${QUOTE}`)}${QUOTE}`;
     return escaped;
   }
   stringify(expression, opts) {
@@ -908,25 +966,25 @@ class WizardParser {
               string += " ";
           }
           if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
-            string += WizardParser.GROUP_BRACKETS[0][0];
+            string += this.CONFIG.symbols.groupBrackets[0][0];
           string += this.stringify(constituent, opts);
           if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
-            string += WizardParser.GROUP_BRACKETS[0][1];
+            string += this.CONFIG.symbols.groupBrackets[0][1];
         }
         break;
       case "condition": {
         const resolveNonImplicit = () => {
           const transformed = this.CONFIG.dialects[dialect][expression.operation];
           const alpha = isAlpha(transformed);
-          string += expression.field;
+          string += expression.field.toString();
           if (!compact || alpha)
             string += " ";
           string += transformed;
           if (!compact || alpha)
             string += " ";
           if (Array.isArray(expression.value)) {
-            const join = expression.value.map((v) => this.addQuotesIfNecessary(v)).join(compact ? WizardParser.ARRAY_DELIMITERS[0] : WizardParser.ARRAY_DELIMITERS[0] + " ");
-            string += `${WizardParser.ARRAY_BRACKETS[0][0]}${join}${WizardParser.ARRAY_BRACKETS[0][1]}`;
+            const join = expression.value.map((v) => this.addQuotesIfNecessary(v)).join(compact ? this.CONFIG.symbols.arrayDelimiters[0] : this.CONFIG.symbols.arrayDelimiters[0] + " ");
+            string += `${this.CONFIG.symbols.arrayBrackets[0][0]}${join}${this.CONFIG.symbols.arrayBrackets[0][1]}`;
           } else
             string += this.addQuotesIfNecessary(expression.value);
         };
@@ -938,12 +996,18 @@ class WizardParser {
             const fieldTypes = fieldType && (Array.isArray(fieldType) ? fieldType : [fieldType]);
             const opTypes = Array.isArray(this.CONFIG.implicitCondition.asType) ? this.CONFIG.implicitCondition.asType : [this.CONFIG.implicitCondition.asType];
             const processed = this.processToken(this.CONFIG.implicitCondition.value);
-            const coerced = this.coerceType(processed, fieldTypes ?? opTypes, opTypes);
+            let coerced;
+            try {
+              coerced = this.coerceType(processed, fieldTypes ?? opTypes, opTypes);
+            } catch {
+              resolveNonImplicit();
+              break;
+            }
             const bothBoolean = typeof coerced === "boolean" && typeof expression.value === "boolean";
             if (coerced.valueOf() === expression.value || bothBoolean) {
               if (bothBoolean && coerced !== expression.value)
                 isNegation = !isNegation;
-              string += `${isNegation ? WizardParser.NEGATORS[0] : ""}${expression.field}`;
+              string += `${isNegation ? this.CONFIG.symbols.negators[0] : ""}${expression.field.toString()}`;
             } else
               resolveNonImplicit();
           } else
@@ -991,23 +1055,23 @@ class WizardParser {
       return "quoted";
     if (!isNaN(Number(segment)))
       return "number";
-    for (const [opening, closing] of WizardParser.ARRAY_BRACKETS) {
+    for (const [opening, closing] of this.CONFIG.symbols.arrayBrackets) {
       if (!activeArrayOpeningBracket && segment === opening)
         return "openingarraybracket";
       else if (activeArrayOpeningBracket === opening && segment === closing)
         return "closingarraybracket";
     }
     if (!activeArrayOpeningBracket) {
-      for (const [opening, closing] of WizardParser.GROUP_BRACKETS) {
+      for (const [opening, closing] of this.CONFIG.symbols.groupBrackets) {
         if (segment === opening)
           return "openinggroupbracket";
         else if (segment === closing)
           return "closinggroupbracket";
       }
     }
-    if (activeArrayOpeningBracket && WizardParser.ARRAY_DELIMITERS.includes(segment))
+    if (activeArrayOpeningBracket && this.CONFIG.symbols.arrayDelimiters.includes(segment))
       return "arraydelimiter";
-    if (!activeArrayOpeningBracket && WizardParser.NEGATORS.includes(segment))
+    if (!activeArrayOpeningBracket && this.CONFIG.symbols.negators.includes(segment))
       return "negator";
     if (!activeArrayOpeningBracket && segment in this.OPERATOR_DICTIONARY) {
       const type = this.OPERATOR_DICTIONARY[segment].type;
@@ -1022,52 +1086,6 @@ class WizardParser {
     return this.OPERATOR_DICTIONARY[alias]?.name;
   }
 }
-// src/execute.ts
-function executeAsKnex(query, expression) {
-  switch (expression.type) {
-    case "group": {
-      let firstHappened = false;
-      for (const constituent of expression.constituents) {
-        query[firstHappened ? expression.operation === "AND" ? "andWhere" : "orWhere" : "where"]((clause) => executeAsKnex(clause, constituent));
-        firstHappened = true;
-      }
-      break;
-    }
-    case "condition":
-      switch (expression.operation) {
-        case "EQUAL":
-          query.where(expression.field, "=", expression.value);
-          break;
-        case "NOTEQUAL":
-          query.where(expression.field, "!=", expression.value);
-          break;
-        case "GEQ":
-          query.where(expression.field, ">=", expression.value);
-          break;
-        case "LEQ":
-          query.where(expression.field, "<=", expression.value);
-          break;
-        case "GREATER":
-          query.where(expression.field, ">", expression.value);
-          break;
-        case "LESS":
-          query.where(expression.field, "<", expression.value);
-          break;
-        case "IN":
-          query.whereIn(expression.field, expression.value);
-          break;
-        case "NOTIN":
-          query.whereNotIn(expression.field, expression.value);
-          break;
-        case "MATCH":
-          query.whereRaw("?? ~* ?", [expression.field, expression.value]);
-          break;
-        case "NOTMATCH":
-          query.whereRaw("?? !~* ?", [expression.field, expression.value]);
-          break;
-      }
-  }
-}
 // src/dominput.ts
 function getCursorIndex(element) {
   const selection = window.getSelection();
@@ -1259,10 +1277,9 @@ function createDOMInput({ input, config, onUpdate, parseOnInitialize }) {
   };
 }
 export {
-  executeAsKnex,
-  createDOMInput,
-  WizardParser,
-  TYPE_PRIORITY,
+  ConstraintError,
   ParseError,
-  ConstraintError
+  TYPE_PRIORITY,
+  WizardParser,
+  createDOMInput
 };

package/dist/parser.d.ts

@@ -58,6 +58,7 @@ type ValidateUppercaseKeys<O extends OperatorRecord> = {
     [K in keyof O]: K extends Uppercase<K & string> ? O[K] : ValidationError<`Operator Record contains non-uppercase key: '${K & string}'`>;
 };
 type InternalOperationDictionary<O extends OperatorRecord> = Record<GetConditionOperators<O> | GetJunctionOperators<O> | string, InternalConditionOperatorDefinition<O> | InternalJunctionOperatorDefinition<O>>;
+type ReadonlyNonemptyArray<T> = readonly [T, ...T[]];
 export interface WizardParserConfig<F extends FieldTypeRecord, O extends OperatorRecord, out V extends boolean, D extends string> {
     /**
      * Restricted fields.\
@@ -69,7 +70,7 @@ export interface WizardParserConfig<F extends FieldTypeRecord, O extends Operato
      * If the query value is of array type, it will check all entries of the array and ensure they're all allowed.\
      * This check runs before type coercion so the value checked will always be a string. However, quotes and escapes WILL be removed
      */
-    restricted?: Partial<Record<keyof F | (string & {}), boolean | ['allow' | 'deny', Array<string | RegExp>]>>;
+    restricted?: Partial<Record<keyof F | (string & {}), boolean | ['allow' | 'deny', ReadonlyArray<string | RegExp>]>>;
     /**
      * The types of fields\
      * Either provide the field type singularly or permit multiple types with an array of field types\
@@ -111,9 +112,24 @@ export interface WizardParserConfig<F extends FieldTypeRecord, O extends Operato
         /** The default implicit value in string form */
         value: string;
         /** How the value should be parsed (as a type) */
-        asType: FieldType | FieldType[];
+        asType: FieldType | readonly FieldType[];
     };
+    /**
+     * A specification of how to stringify a parsed expression.\
+     * Provide a record that maps dialect names to a record which maps operator names to their stringified expressions
+     */
     dialects?: Record<D, Record<GetOperators<O>, string>>;
+    /**
+     * Symbol overrides.\
+     * Stringification will use the first symbol entry of each symbol type.
+     */
+    symbols?: {
+        quotes?: ReadonlyNonemptyArray<string>;
+        negators?: ReadonlyNonemptyArray<string>;
+        arrayDelimiters?: ReadonlyNonemptyArray<string>;
+        arrayBrackets?: ReadonlyNonemptyArray<[opening: string, closing: string]>;
+        groupBrackets?: ReadonlyNonemptyArray<[opening: string, closing: string]>;
+    };
 }
 export interface StringifyOptions<D extends string> {
     /**
@@ -237,13 +253,15 @@ export declare class WizardParser<const F extends FieldTypeRecord, const O exten
             readonly NOTMATCH: "≇";
         };
     };
-    protected static readonly QUOTES: readonly ["'", "\"", "`"];
-    protected static readonly NEGATORS: readonly ["!"];
-    protected static readonly ARRAY_DELIMITERS: readonly [","];
-    protected static readonly ARRAY_BRACKETS: [["[", "]"], ["{", "}"]];
-    protected static readonly GROUP_BRACKETS: [["(", ")"]];
+    static readonly DEFAULT_QUOTES: readonly ["\"", "'", "`"];
+    static readonly DEFAULT_NEGATORS: readonly ["!"];
+    static readonly DEFAULT_ARRAY_DELIMITERS: readonly [","];
+    static readonly DEFAULT_ARRAY_BRACKETS: [["[", "]"], ["{", "}"]];
+    static readonly DEFAULT_GROUP_BRACKETS: [["(", ")"]];
     protected readonly OPERATOR_DICTIONARY: InternalOperationDictionary<O>;
-    protected readonly CONFIG: WizardParserConfig<F, O, V, D> & Required<Pick<WizardParserConfig<F, O, V, D>, 'operators'>>;
+    protected readonly CONFIG: WizardParserConfig<F, O, V, D> & Required<Pick<WizardParserConfig<F, O, V, D>, 'operators'>> & {
+        symbols: Required<Exclude<WizardParserConfig<F, O, V, D>['symbols'], undefined>>;
+    };
     protected readonly TOKEN_REGEX: RegExp;
     protected readonly QUOTE_REGEX: RegExp;
     protected readonly QUOTE_EDGE_REGEX: RegExp;
@@ -310,7 +328,7 @@ export declare class WizardParser<const F extends FieldTypeRecord, const O exten
      * @param           fieldTypes     The supported field types
      * @param           operatorTypes  The supported operator types
      * @returns                        The coerced type
-     * @throws  {Error}                Message is 'operator' if the operator type cannot be coerced and 'field' if the field type cannot be coerced
+     * @throws  {Error}                Message is 'operator' if the operator type cannot be coerced, 'field' if the field type cannot be coerced and 'disagreement' if the allowed types for the field and operator have no overlap
      */
     protected coerceType(processedToken: ProcessedToken, fieldTypes: FieldType[], operatorTypes: FieldType[]): Primitive;
     /**
@@ -353,7 +371,7 @@ export declare class WizardParser<const F extends FieldTypeRecord, const O exten
      * @throws  {Error}            If no dialect dictionary is defined or dialect supplied is unknown
      * @returns                    The formatted string
      */
-    stringify(expression: Expression<FieldTypeRecord, O>, opts: D | StringifyOptions<D>): string;
+    stringify(expression: Expression<F, O>, opts: D | StringifyOptions<D>): string;
     /**
      * (Get an array entry from a map or insert one) and return it
      * @param map The map

package/dist/spec.d.ts

@@ -51,18 +51,31 @@ export type GetConditionTSType<T extends ConditionOperatorComparisonType> = {
     numeric: number | Date;
     array: Primitive[];
 }[T];
+/**
+ * The TS type of a condition value belonging to a field with no declared types\
+ * Values are only parsed into dates for fields declared as dates, so a date can only occur when the operator itself is exclusively date-typed
+ */
+export type GetUndeclaredConditionTSType<T extends ConditionOperatorComparisonType> = {
+    primitive: Exclude<Primitive, Date>;
+    boolean: boolean;
+    string: string;
+    number: number;
+    date: Date;
+    numeric: number;
+    array: Array<Exclude<Primitive, Date>>;
+}[T];
 export interface CheckedCondition<F extends FieldTypeRecord = FieldTypeRecord, O extends OperatorRecord = OperatorRecord, I extends keyof F = keyof F, P extends GetConditionOperators<O> = GetConditionOperators<O>> {
     type: 'condition';
     operation: P;
     field: I;
-    value: GetOperatorDefinition<O, P>['type'] extends 'array' ? Array<GetFieldTSType<F[I]>> : Extract<GetConditionTSType<GetOperatorDefinition<O, P>['type'] & ConditionOperatorComparisonType>, GetFieldTSType<F[I]>>;
+    value: string extends I ? GetUndeclaredConditionTSType<GetOperatorDefinition<O, P>['type'] & ConditionOperatorComparisonType> : GetOperatorDefinition<O, P>['type'] extends 'array' ? Array<GetFieldTSType<F[I]>> : Extract<GetConditionTSType<GetOperatorDefinition<O, P>['type'] & ConditionOperatorComparisonType>, GetFieldTSType<F[I]>>;
     validated: true;
 }
 export interface UncheckedCondition<O extends OperatorRecord = OperatorRecord, P extends GetConditionOperators<O> = GetConditionOperators<O>> {
     type: 'condition';
     operation: P;
     field: string;
-    value: GetOperatorDefinition<O, P>['type'] extends 'array' ? Primitive[] : GetConditionTSType<GetOperatorDefinition<O, P>['type'] & ConditionOperatorComparisonType>;
+    value: GetUndeclaredConditionTSType<GetOperatorDefinition<O, P>['type'] & ConditionOperatorComparisonType>;
     validated: false;
 }
 export interface Group<F extends FieldTypeRecord = FieldTypeRecord, O extends OperatorRecord = OperatorRecord, V extends boolean = false> {

package/package.json

@@ -6,7 +6,7 @@
   },
   "homepage": "https://github.com/exoRift/wizard-ql",
   "description": "WizardQL is a natural-language-like query language for constructing data queries for resources that meet conditions.",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/exoRift/wizard-ql.git"
@@ -45,9 +45,6 @@
     "eslint-plugin-jsdoc": "^50.6.11",
     "tsd": "^0.33.0"
   },
-  "optionalDependencies": {
-    "knex": "^3.1.0"
-  },
   "peerDependencies": {
     "typescript": "^5.8.3"
   }

package/dist/execute.d.ts

@@ -1,10 +0,0 @@
-import type { Knex } from 'knex';
-import type { Expression, FieldTypeRecord } from './spec';
-import type { WizardParser } from './parser';
-/**
- * Execute a Wizard expression as a SQL query\
- * This mutates the passed query
- * @param query      The Knex query to append conditions to
- * @param expression The Wizard expression
- */
-export declare function executeAsKnex(query: Knex.QueryBuilder, expression: Expression<FieldTypeRecord, typeof WizardParser.DEFAULT_OPERATORS>): void;