@witchcraft/expressit 0.2.1 → 0.3.0

package/src/ast/createGroupNode.ts

@@ -9,15 +9,15 @@ export function createGroupNode<
 	TPrefix extends
 		TPrefixable extends true
 			? ConditionNode<TValid> |
-			ValidToken<TOKEN_TYPE.NOT> |
+			ValidToken<typeof TOKEN_TYPE.NOT> |
 			undefined
-			: ValidToken<TOKEN_TYPE.NOT> |
+			: ValidToken<typeof TOKEN_TYPE.NOT> |
 			undefined =
 		TPrefixable extends true
 			? ConditionNode<TValid> |
-			ValidToken<TOKEN_TYPE.NOT> |
+			ValidToken<typeof TOKEN_TYPE.NOT> |
 			undefined
-			: ValidToken<TOKEN_TYPE.NOT>,
+			: ValidToken<typeof TOKEN_TYPE.NOT>,
 >(raw: {
 	prefix: TPrefix
 } & RawNode<GroupNode<TValid>>): GroupNode<TValid, TPrefixable, TPrefix> {

package/src/ast/createToken.ts

@@ -1,21 +1,21 @@
 import { ExpressitError } from "../internal/ExpressitError.js"
-import type { ErrorToken, RawToken, TOKEN_TYPE, ValidToken } from "../types/ast.js"
-import { ERROR_CODES } from "../types/errors.js"
+import type { ErrorToken, RawToken, TokenType, ValidToken } from "../types/ast.js"
+import { PARSER_ERROR } from "../types/errors.js"
 
 export function createToken<
-	TType extends TOKEN_TYPE,
+	TType extends TokenType,
 >(raw: { type: TType } & RawToken<ValidToken>): ValidToken<TType>
 export function createToken(raw: RawToken<ErrorToken>): ErrorToken
 export function createToken<
 	TValid extends boolean = boolean,
 	TType extends
-		TValid extends true ? TOKEN_TYPE : never =
-		TValid extends true ? TOKEN_TYPE : never,
+		TValid extends true ? TokenType : never =
+		TValid extends true ? TokenType : never
 >(raw: RawToken<ValidToken> | RawToken<ErrorToken>): TValid extends true
 ? ValidToken<TType>
 : ErrorToken {
 	if (raw.start === undefined || raw.end === undefined) {
-		throw new ExpressitError(ERROR_CODES.PARSER_POSITION_ERROR, raw)
+		throw new ExpressitError(PARSER_ERROR.POSITION_ERROR, raw)
 	}
 	return {
 		...raw,

package/src/ast/error.ts

@@ -1,8 +1,8 @@
 import { createToken } from "./createToken.js"
 
-import { type ErrorToken,type TOKEN_TYPE } from "../types/ast.js"
+import { type ErrorToken,type TokenType } from "../types/ast.js"
 
-export function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken {
+export function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken {
 	if (pos === undefined) throw new Error("should never happen, passed undefined position for error token")
 	return createToken({ expected, start: pos, end: pos })
 }

package/src/ast/handlers.ts

@@ -7,28 +7,28 @@ import { createGroupNode } from "./createGroupNode.js"
 import { createToken } from "./createToken.js"
 import { createVariableNode } from "./createVariableNode.js"
 
-import { type AnyToken, type ArrayNode,AST_TYPE,type ConditionNode, type ErrorToken, type ExpressionNode,type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type TokenBooleanTypes, type TokenDelimiterTypes, type TokenOperatorTypes, type TokenQuoteTypes, type ValidToken, type VariableNode } from "../types/ast.js"
+import { type AnyToken, type ArrayNode,AST_TYPE,type ConditionNode, type ErrorToken, type ExpressionNode,type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type TokenBoolean, type TokenDelimiter, type TokenOperator, type TokenQuote, type TokenType, type ValidToken, type VariableNode } from "../types/ast.js"
 
 
 /* #region HELPERS */
-function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken {
+function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken {
 	if (pos === undefined) throw new Error("should never happen, passed undefined position for error token")
 	return createToken({ expected, start: pos, end: pos })
 }
 /* #regionend */
 
 /* #region TOKENS */
-const operators = <T extends TokenOperatorTypes>
+const operators = <T extends TokenOperator>
 (type: T) =>
 	(value: string, pos: Position): ValidToken<T> => createToken({ value, type, ...pos })
 
-const delimiters = <T extends TokenDelimiterTypes>
+const delimiters = <T extends TokenDelimiter>
 (type: T) =>
 	(value: string | undefined, pos: Position): ValidToken<T> | undefined =>
 		// check must be falsy, we want to return undefined when given ""
 		value ? createToken({ value, type, ...pos }) : undefined
 
-const maybeToken = <T extends TOKEN_TYPE> (type: T) => <TVal extends string | undefined> (value: TVal, pos: Position): TVal extends string ? ValidToken<T> : ErrorToken => {
+const maybeToken = <T extends TokenType> (type: T) => <TVal extends string | undefined> (value: TVal, pos: Position): TVal extends string ? ValidToken<T> : ErrorToken => {
 	if (value === undefined) {
 		return error(pos.end, [type]) as any
 	} else {
@@ -63,11 +63,11 @@ export const operator = {
 
 /* #region AST NODES */
 export function variable(
-	prefix: ValidToken<TOKEN_TYPE.VALUE> | null | undefined,
-	quoteL: AnyToken<TokenQuoteTypes> | null | undefined,
-	value: AnyToken<TOKEN_TYPE.VALUE> | null | undefined,
-	quoteR: AnyToken<TokenQuoteTypes> | null | undefined,
-	flags?: ValidToken<TOKEN_TYPE.VALUE>,
+	prefix: ValidToken<typeof TOKEN_TYPE.VALUE> | null | undefined,
+	quoteL: AnyToken<TokenQuote> | null | undefined,
+	value: AnyToken<typeof TOKEN_TYPE.VALUE> | null | undefined,
+	quoteR: AnyToken<TokenQuote> | null | undefined,
+	flags?: ValidToken<typeof TOKEN_TYPE.VALUE>,
 ): VariableNode {
 	const node: FirstParam<typeof createVariableNode> = {
 		prefix: prefix ?? undefined,
@@ -92,19 +92,19 @@ export function variable(
 
 
 export function condition(
-	not: ValidToken<TOKEN_TYPE.NOT> | null | undefined,
+	not: ValidToken<typeof TOKEN_TYPE.NOT> | null | undefined,
 	property: VariableNode | null | undefined,
 	{ propertyOperator, sepL, sepR }: {
 		propertyOperator?: ConditionNode["propertyOperator"] | null
-		sepL?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> | null
-		sepR?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> | null
+		sepL?: ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP> | null
+		sepR?: ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP> | null
 	} = {},
 	value?: VariableNode | GroupNode | ArrayNode | null,
 ): ConditionNode {
 	const start = (not?.start ?? property?.start ?? sepL?.start ?? propertyOperator?.start ?? sepR?.start ?? value?.start)!
 	const end = (value?.end ?? sepR?.end ?? propertyOperator?.end ?? sepL?.end ?? property?.end ?? not?.end)!
 	const node: FirstParam<typeof createConditionNode> = {
-		value: value ? value : error(end, [TOKEN_TYPE.VALUE]),
+		value: value ?? error(end, [TOKEN_TYPE.VALUE]),
 		start,
 		end,
 	}
@@ -115,22 +115,22 @@ export function condition(
 		node.sep = {}
 		if (sepL) {
 			node.sep.left = sepL
-			node.property ||= error(sepL.start, [TOKEN_TYPE.VALUE])
-			node.propertyOperator ||= error(sepL?.end ?? sepR?.start, [TOKEN_TYPE.VALUE])
+			node.property ??= error(sepL.start, [TOKEN_TYPE.VALUE])
+			node.propertyOperator ??= error(sepL?.end ?? sepR?.start, [TOKEN_TYPE.VALUE])
 		}
 		if (sepR) node.sep.right = sepR
 		else if (!node.value || node.value.type === AST_TYPE.VARIABLE) {
 			node.sep.right = error(node.value?.start ?? end, [TOKEN_TYPE.OP_EXPANDED_SEP])
 		}
 	} else if (propertyOperator) {
-		node.property ||= error(propertyOperator.start, [TOKEN_TYPE.VALUE])
+		node.property ??= error(propertyOperator.start, [TOKEN_TYPE.VALUE])
 	}
 	return createConditionNode(node as ConditionNode)
 }
 
 export function expression(
 	left: ConditionNode | GroupNode | null | undefined,
-	operator: ValidToken<TokenBooleanTypes> | null | undefined,
+	operator: ValidToken<TokenBoolean> | null | undefined,
 	right: ConditionNode | GroupNode | null | undefined,
 ): ExpressionNode {
 	return createExpressionNode({
@@ -143,11 +143,11 @@ export function expression(
 }
 
 export function group(
-	operator: ValidToken<TOKEN_TYPE.NOT> | null | undefined,
+	operator: ValidToken<typeof TOKEN_TYPE.NOT> | null | undefined,
 	prefix: ConditionNode | null | undefined,
-	parenL: ValidToken<TOKEN_TYPE.PARENL> | null | undefined,
+	parenL: ValidToken<typeof TOKEN_TYPE.PARENL> | null | undefined,
 	condition: GroupNode["expression"],
-	parenR: ValidToken<TOKEN_TYPE.PARENR> | null | undefined,
+	parenR: ValidToken<typeof TOKEN_TYPE.PARENR> | null | undefined,
 ): GroupNode {
 	return createGroupNode({
 		prefix: prefix ?? operator ?? undefined,
@@ -162,9 +162,9 @@ export function group(
 }
 
 export function array(
-	bracketL: ValidToken<TOKEN_TYPE.BRACKETL>,
+	bracketL: ValidToken<typeof TOKEN_TYPE.BRACKETL>,
 	values: VariableNode[],
-	bracketR: ValidToken<TOKEN_TYPE.BRACKETR> | null | undefined,
+	bracketR: ValidToken<typeof TOKEN_TYPE.BRACKETR> | null | undefined,
 ): ArrayNode {
 	return createArrayNode({
 		values,

package/src/examples/ParserWithSqlSupport.ts

@@ -0,0 +1,371 @@
+import { unreachable } from "@alanscodelog/utils/unreachable.js"
+
+import { Parser } from "../Parser.js"
+import { AST_TYPE, type NormalizedCondition, type NormalizedExpression, type Position,TOKEN_TYPE } from "../types/ast.js"
+
+export interface BasePropertyDefinition {
+	name: string
+	/** Supported types are: string, boolean, int, float, date. */
+	type: string
+	/** Return how to access the column in the WHERE condition of the SQL query, useful for json properties. It is up to you to properly quote the value if needed. */
+	transformToColumn?: (key: string, name: string) => string
+	/**
+	 * A function that can be used to transform the value before it is inserted into the SQL query. Useful for types like arrays. It is up to you to properly escape values if you use the second parameter which contains the unescaped value.
+	 */
+	transformValue?: (value: any, unescapedValue: any) => any | any[]
+	isArray?: boolean
+	/** If undefined, it's assumed all operators are supported. This should only include the final operator (see {@link BaseOperatorDefinition.operator}), it doesn't need to include it's aliases. */
+	supportedOperators?: string[]
+	/** Further transform the value after the basic parsing has been done. Useful to, for example, parse other strings (e.g. now, today, tomorrow) as dates. */
+	postParse?: (value: any) => any
+}
+export interface BaseOperatorDefinition {
+	/** The final operator to use in the SQL query and while evaluating. */
+	operator: string
+	/** All aliases the user can use to specify the operator. They need not include the real final operator. */
+	operators: string[]
+	/** All negated aliases to the operator. If an operator is listed here, it will be used to "invert" a condition when normalizing. e.g. < can list >= as a negated operator. This greatly simplifies queries. */
+	negatedOperators?: string[]
+	/** How to compare the value when evualuating a condition. This is only used if using `evaluate`. */
+	valueComparer: (condition: any, contextValue: any) => boolean
+}
+export type SqlParserError =
+	| "invalidKey"
+	| "unknownProperty"
+	| "unknownOperator"
+	| "unknownOperatorForType"
+	| "invalidValueType"
+/*
+ * Creates an example parser with a `toSql` method that can be used to convert an AST to a a safe SQL query.
+ *
+ * The parser assumes all column names (i.e. the propertyDefinitions) and operators (i.e. operatorDefinitions) are vetted and safe to use in the SQL queries. They are double quoted (unless transformToColumn is specificed) so you can use special characters if needed. You can use the `transformToColumn` option to specify a custom name (e.g. for json columns) that will be left as is.
+ *
+ * Values are escaped with the given `sqlEscapeValue`. If using drizzle, for simple tables and types, you can just do and it'll be safe. More complex types, such as arrays, or json properties are more comlicated and you'll probably want to specify the definition's transformValue option. See the examples tests for examples.
+ * ```ts
+ * const parser = new ParserWithSqlSupport(
+ * 	propertyDefinitions,
+ * 	{
+ * 		sqlEscapeValue: (value: string) => sql`${value}`
+ * 	}
+ * )
+ * ```
+ *
+ */
+export class ParserWithSqlSupport<TErrorToken extends
+	Position & {
+		type: SqlParserError
+		message?: string
+	} =
+	Position & {
+		type: SqlParserError
+		message?: string
+	},
+	TPropertyDefinition extends BasePropertyDefinition = BasePropertyDefinition,
+	TPropertyDefinitions extends Record<string, TPropertyDefinition> = Record<string, TPropertyDefinition>,
+	TOperatorDefinition extends BaseOperatorDefinition = BaseOperatorDefinition,
+	TOperatorDefinitions extends Record<string, TOperatorDefinition> = Record<string, TOperatorDefinition>,
+	TSqlEscapeValue extends (value: string) => any | ReturnType<TSqlEscapeValue> = (value: string) => any,
+> extends Parser<TErrorToken> {
+	sqlEscapeValue: TSqlEscapeValue
+
+	operatorMap: Record<string, string>
+
+	propertyDefinitions: TPropertyDefinitions
+
+	operatorDefinitions: TOperatorDefinitions
+
+	constructor(
+		propertyDefinitions: TPropertyDefinitions,
+		operatorDefinitions: TOperatorDefinitions,
+		{ sqlEscapeValue }: { sqlEscapeValue: TSqlEscapeValue }
+	) {
+		const operators = []
+		const operatorMap: Record<string, string> = {}
+		for (const value of Object.values(operatorDefinitions)) {
+			for (const operator of value.operators) {
+				operatorMap[operator] = value.operator
+				operators.push(operator)
+			}
+			if (value.negatedOperators) {
+				for (const operator of value.negatedOperators) {
+					operatorMap[operator] = value.operator
+					operators.push(operator)
+				}
+			}
+		}
+		super({
+			arrayValues: true,
+			regexValues: false,
+			keywords: {
+				and: [{ isSymbol: true, value: "&&" }],
+				or: [{ isSymbol: true, value: "||" }],
+				not: [{ isSymbol: true, value: "!" }],
+			},
+			customPropertyOperators: operators,
+			prefixableGroups: false,
+			valueComparer: (condition, contextValue, _context) => {
+				if (typeof condition.value !== typeof contextValue) {
+					throw new Error(`Expected type of property ${condition.property[0]} to be the same type as the context value ${contextValue} (${typeof contextValue}). If the ast has been validated this is likely because the type of the context value is incorrect.`)
+				}
+				
+				const prop = condition.property[0]
+				if (!prop) unreachable("Did you validate the ast before evaluating it?")
+
+				const propDefinition = propertyDefinitions[prop]
+				const operatorDefinition = condition.operator && operatorDefinitions[condition.operator]
+				if (!operatorDefinition) unreachable("Did you validate the ast before evaluating it?")
+
+				const isSupported = !propDefinition.supportedOperators?.includes(condition.operator!)
+				if (!isSupported) unreachable("Did you validate the ast before evaluating it?")
+
+				const res = operatorDefinition.valueComparer(condition, contextValue)
+				return res
+			},
+			valueValidator: (_contextValue, query): TErrorToken[] | void => {
+				const prop = query.propertyKeys[0]
+				let tokens: TErrorToken[] = []
+				const propDefinition = propertyDefinitions[prop]
+				if (!propDefinition) {
+					tokens = tokens.concat(query.property.map(token => ({
+						start: token.start,
+						end: token.end,
+						type: "unknownProperty",
+					})) as TErrorToken[])
+					return tokens
+				}
+				const op = query.operator
+				const opKey = op && operatorMap[op.value]
+				if (!op || !opKey) {
+					tokens.push({
+						start: (op ?? query.condition)?.start,
+						end: (op ?? query.condition)?.end,
+						type: "unknownOperator",
+					} as TErrorToken)
+				} else {
+					if (propDefinition.supportedOperators && !propDefinition.supportedOperators?.includes(opKey)) {
+						tokens.push({
+							start: query.condition.start,
+							end: query.condition.end,
+							type: "unknownOperatorForType",
+						} as TErrorToken)
+					}
+				}
+
+				const val = query.value
+				if (Array.isArray(val)) {
+					for (const v of val) {
+						if (v.type !== "VARIABLE") unreachable()
+						const res = convertAndValidateValue(query.isQuoted, v.value.value, prop, propertyDefinitions, { isArray: true })
+						if (res instanceof Error) {
+							if (v.type !== "VARIABLE") unreachable()
+							const token = v
+							tokens.push({
+								start: token.start,
+								end: token.end,
+								type: "invalidValueType",
+								message: res.message,
+							} as TErrorToken)
+						}
+					}
+					if (tokens.length > 0) return tokens
+					return
+				}
+
+				if (val?.type !== "VARIABLE") unreachable()
+				const value = val.value.value
+				const res = convertAndValidateValue(query.isQuoted, value, prop, propertyDefinitions)
+				if (res instanceof Error) {
+					if (!query.value || query.value.type !== "VARIABLE") unreachable()
+					const token = query.value.value
+					tokens.push({
+						start: token.start,
+						end: token.end,
+						type: "invalidValueType",
+						message: res.message,
+					} as TErrorToken)
+				}
+				
+				if (tokens.length > 0) return tokens
+			},
+			conditionNormalizer(query) {
+				const prop = query.property?.[0]
+				if (!prop) unreachable("Did you validate the ast before normalizing it?")
+				const propDefinition = propertyDefinitions[prop]
+
+				let finalValue
+				if (Array.isArray(query.value)) {
+					const values = []
+					if (query.condition.value.type !== AST_TYPE.ARRAY) unreachable()
+					const raw = query.condition.value.values
+					for (let i = 0; i < query.value.length; i += 1) {
+						const token = raw[i]
+						const val = query.value[i]
+						const isQuoted = !!token.quote
+						const res = convertAndValidateValue(isQuoted, val, prop, propertyDefinitions, { isArray: true })
+						if (res instanceof Error) throw res
+						values.push(res)
+					}
+					finalValue = values
+				} else {
+					finalValue = convertAndValidateValue(query.isQuoted, query.value, prop, propertyDefinitions)
+					if (propDefinition.isArray) {
+						finalValue = [finalValue]
+					}
+				}
+
+				let finalOperator: any = query.operator
+				if (finalValue instanceof Error) throw finalValue
+				const opKey = query.operator && operatorMap[query.operator]
+				if (!opKey) unreachable("Did you validate the ast before normalizing it?")
+					
+				const operatorDefinition = opKey && operatorDefinitions[opKey]
+				if (!operatorDefinition) unreachable("Did you validate the ast before normalizing it?")
+			
+
+				const isNegatableOperator = operatorDefinition.negatedOperators?.includes(query.operator!)
+
+				finalOperator = operatorDefinition.operator
+				let isNegated = query.isNegated
+				if (isNegatableOperator) {
+					isNegated = !isNegated
+				}
+				
+				return { value: finalValue, operator: finalOperator, negate: isNegated }
+			},
+		})
+		this.propertyDefinitions = propertyDefinitions
+		this.operatorDefinitions = operatorDefinitions
+		this.operatorMap = operatorMap
+		this.sqlEscapeValue = sqlEscapeValue
+	}
+	
+	toSql<T>(
+		ast: NormalizedExpression<any, any> | NormalizedCondition<any, any>,
+		/**
+		 * Optionally convert the raw strings to something else. If uding drizzle, you can pass sql.raw here. So later you can just sql.join the return of the function:
+		 *
+		 * ```ts
+		 * sql.join([
+		 * 	sql.raw(db.select().from(someTable).toSQL().sql),
+		 * 	sql.raw(`where`),
+		 * 	...parser.toSql(ast, sql.raw)
+		 * ], sql` `)
+		 * ```
+		 */
+		wrapStrings?: (value: string) => T,
+	): (ReturnType<TSqlEscapeValue> | typeof wrapStrings extends undefined ? string : T)[] {
+		this._checkEvaluationOptions()
+		const chunks = []
+
+		if (ast.type === AST_TYPE.NORMALIZED_CONDITION) {
+			const prop = ast.property?.[0]
+			const definition = this.propertyDefinitions[prop]
+			const value = ast.value
+			const col = definition.transformToColumn?.(prop, definition.name) ?? `"${prop}"`
+			const op = ast.operator
+			if (ast.negate) {
+				chunks.push(wrapStrings?.(`NOT(`) ?? `NOT(`)
+			}
+			chunks.push(wrapStrings?.(`${col} `) ?? `${col} `)
+			chunks.push(wrapStrings?.(`${op} `) ?? `${op} `)
+			const val = this.sqlEscapeValue(value)
+			if (definition.transformValue) {
+				const transformed = definition.transformValue(val, value)
+				if (Array.isArray(transformed)) {
+					chunks.push(...transformed)
+				} else {
+					chunks.push(transformed)
+				}
+			} else {
+				chunks.push(val)
+			}
+			if (ast.negate) {
+				chunks.push(wrapStrings?.(`)`) ?? `)`)
+			}
+			return chunks
+		}
+		if (ast.type === AST_TYPE.NORMALIZED_EXPRESSION) {
+			const left = this.toSql(ast.left, wrapStrings)
+			const right = this.toSql(ast.right, wrapStrings)
+			const op = ast.operator === TOKEN_TYPE.AND ? "AND" : "OR"
+			chunks.push(wrapStrings?.(`(`) ?? `(`)
+			chunks.push(...left)
+			chunks.push(wrapStrings?.(` ${op} `) ?? ` ${op} `)
+			chunks.push(...right)
+			chunks.push(wrapStrings?.(`)`) ?? `)`)
+			return chunks as any
+		}
+
+		return unreachable()
+	}
+}
+export function createTypeError(prop: string, type: string, isArray: boolean): Error {
+	if (isArray) {
+		return new Error(`Property ${prop} must contain items of type ${type}.`)
+	}
+	return new Error(`Property ${prop} must be of type ${type}.`)
+}
+
+export function convertAndValidateValue(
+	isQuoted: boolean,
+	value: any,
+	prop: string,
+	propertyDefinitions: Record<string, BasePropertyDefinition>,
+	{ isArray = false }: { isArray?: boolean } = {},
+): any {
+	let finalValue: any = value
+	let isFloat = false
+	const propDefinition = propertyDefinitions[prop]
+	
+	if (typeof value === "string" && !isQuoted) {
+		if (finalValue === "true") {
+			finalValue = true
+		} else if (finalValue === "false") {
+			finalValue = false
+		} else {
+			const asNum = parseInt(value, 10)
+			if (!isNaN(asNum)) {
+				finalValue = asNum
+			} else {
+				const asFloat = parseFloat(value)
+				if (!isNaN(asFloat)) {
+					finalValue = asFloat
+					isFloat = true
+				}
+			}
+		}
+	}
+	const type = propDefinition.type
+	finalValue = propDefinition.postParse?.(finalValue) ?? finalValue
+
+	switch (type) {
+		case "integer":
+		case "float": {
+			if (typeof finalValue !== "number" || (type === "float" && !isFloat) || (type === "integer" && isFloat)) {
+				return createTypeError(prop, type, isArray)
+			}
+			break
+		}
+		case "string":
+		case "boolean": {
+			if (typeof finalValue !== propDefinition.type) {
+				return createTypeError(prop, type, isArray)
+			}
+			break
+		}
+		case "date": {
+			if (finalValue instanceof Date) {
+				break
+			}
+			const maybeDate = new Date(finalValue)
+			if (isNaN(maybeDate.getTime())) {
+				return createTypeError(prop, "date", isArray)
+			} else {
+				finalValue = maybeDate
+			}
+			break
+		}
+	}
+	
+	return finalValue
+}

package/src/examples/{shortcutContextParser.ts → ShortcutContextParser.ts}

@@ -1,3 +1,7 @@
+import { Parser } from "../Parser.js"
+import type { Position } from "../types/ast.js"
+import type { ValueQuery } from "../types/parser.js"
+
 /* TODO TOUPDATE */
 /**
  * A pre-configured parser for parsing shortcut contexts (similar to VSCode's [when clause contexts](https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts)).
@@ -9,15 +13,11 @@
  * The validate function will return a list of positions with a list of errors which includes handling invalid or duplicate regex flags.
  */
 
-import { Parser } from "../Parser.js"
-import type { Position } from "../types/ast.js"
-import type { ValueQuery } from "../types/parser.js"
-
 
-export class ShortcutContextParser<T extends
+export class ShortcutContextParser<TErrorTokens extends
 	Position & { type: ("invalidKey" | "unregexableKey" | "invalidRegexFlag" | "duplicateRegexFlag") } =
 	Position & { type: ("invalidKey" | "unregexableKey" | "invalidRegexFlag" | "duplicateRegexFlag") },
-> extends Parser<T> {
+> extends Parser<TErrorTokens> {
 	validKeys: string[] = []
 
 	regexablekeys: string[] = []
@@ -49,21 +49,21 @@ export class ShortcutContextParser<T extends
 				}
 				return contextValue === condition.value
 			},
-			valueValidator: (_contextValue, query): T[] | void => {
-				let tokens: T[] = []
+			valueValidator: (_contextValue, query): TErrorTokens[] | void => {
+				let tokens: TErrorTokens[] = []
 				if (!this.validKeys.includes(query.propertyName!)) {
 					tokens = tokens.concat(query.property.map(token => ({
 						start: token.start,
 						end: token.end,
 						type: "invalidKey",
-					})) as T[])
+					})) as TErrorTokens[])
 				}
 				if (query.isRegex && !this.regexablekeys.includes(query.propertyName!)) {
 					tokens = tokens.concat(query.property.map(token => ({
 						start: token.start,
 						end: token.end,
 						type: "unregexableKey",
-					})) as T[])
+					})) as TErrorTokens[])
 				}
 				if (query.regexFlags) {
 					const chars = query.regexFlags.value.split("")
@@ -75,14 +75,14 @@ export class ShortcutContextParser<T extends
 								start: start + i,
 								end: start + i + 1,
 								type: "duplicateRegexFlag",
-							} as T)
+							} as TErrorTokens)
 						}
 						if (!validRegexFlags.includes(char)) {
 							tokens.push({
 								start: start + i,
 								end: start + i + 1,
 								type: "invalidRegexFlag",
-							} as T)
+							} as TErrorTokens)
 						}
 					}
 				}
@@ -93,7 +93,7 @@ export class ShortcutContextParser<T extends
 				let finalOperator: any = operator
 				// another way to allow special unquoted value types is something like this:
 				if (typeof value === "string" && !isQuoted) {
-					const asNum = parseInt(value, 2)
+					const asNum = parseInt(value, 10)
 					if (!isNaN(asNum)) finalValue = asNum
 					if (["true", "false"].includes(value)) {
 						finalValue = value === "true"
@@ -132,7 +132,7 @@ export class ShortcutContextParser<T extends
 		for (const key of Object.keys(context)) {
 			if (typeof context[key] === "boolean") {
 				this.validKeys.push(prev ? `${prev}.${key}` : key)
-				if (context[key] === true) {
+				if (context[key]) {
 					this.regexablekeys.push(prev ? `${prev}.${key}` : key)
 				}
 			} else {

package/src/examples/index.ts

@@ -1,3 +1,4 @@
 /* Autogenerated Index */
 
-export { ShortcutContextParser } from "./shortcutContextParser.js"
+export { ShortcutContextParser } from "./ShortcutContextParser.js"
+export { ParserWithSqlSupport } from "./ParserWithSqlSupport.js"

package/src/internal/ExpressitError.ts

@@ -3,12 +3,12 @@ import { indent } from "@alanscodelog/utils/indent.js"
 import { pretty } from "@alanscodelog/utils/pretty.js"
 import type { Keys } from "@alanscodelog/utils/types"
 
-// @ts-expect-error todo
-import { repository, version } from "../package.js"
-import type { ERROR_CODES, ErrorInfo } from "../types/errors.js"
+import packageJson from "../../package.json" with { type: "json" }
+const { version, repository } = packageJson
+import type { ErrorInfo, ParserError } from "../types/errors.js"
 
 /** @internal */
-export class ExpressitError<T extends ERROR_CODES> extends Error {
+export class ExpressitError<T extends ParserError> extends Error {
 	version: string = version
 
 	repo: string = repository