qast 1.0.0

package/dist/adapters/sequelize.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSequelizeFilter = toSequelizeFilter;
+const ast_1 = require("../types/ast");
+/**
+ * Transform a QAST AST node to a Sequelize filter
+ *
+ * IMPORTANT: Sequelize uses the Op object from 'sequelize', not $ operators.
+ * This adapter returns a structure with metadata that you need to transform.
+ *
+ * Example usage:
+ * ```ts
+ * import { Op } from 'sequelize';
+ * import { toSequelizeFilter } from 'qast';
+ *
+ * const filter = toSequelizeFilter(ast);
+ * // Returns a structure like:
+ * // { age: { __qast_operator__: 'gt', value: 25 } }
+ * // You need to transform it:
+ * // { age: { [Op.gt]: 25 } }
+ * ```
+ *
+ * For simple equality (eq operator), you can use plain values directly.
+ */
+function toSequelizeFilter(ast) {
+    return transformNode(ast);
+}
+/**
+ * Transform a node to Sequelize format
+ */
+function transformNode(node) {
+    if ((0, ast_1.isComparisonNode)(node)) {
+        return transformComparisonNode(node);
+    }
+    else if ((0, ast_1.isLogicalNode)(node)) {
+        return transformLogicalNode(node);
+    }
+    throw new Error('Invalid node type');
+}
+/**
+ * Transform a comparison node to Sequelize format
+ *
+ * Sequelize uses Op operators from 'sequelize' package.
+ * Since we cannot import Op (optional peer dependency), we return metadata
+ * that users can transform to use Op operators.
+ *
+ * For equality (eq), Sequelize accepts plain values, so we return them directly.
+ * For other operators, we return metadata that indicates the operator type.
+ */
+function transformComparisonNode(node) {
+    const { field, op, value } = node;
+    // For equality, Sequelize accepts plain values
+    if (op === 'eq') {
+        return { [field]: value };
+    }
+    // For other operators, return metadata that can be transformed to use Op
+    // Users need to import Op from 'sequelize' and transform:
+    // { __qast_operator__: 'gt', value: 25 } -> { [Op.gt]: 25 }
+    switch (op) {
+        case 'ne':
+            return { [field]: { __qast_operator__: 'ne', value } };
+        case 'gt':
+            return { [field]: { __qast_operator__: 'gt', value } };
+        case 'lt':
+            return { [field]: { __qast_operator__: 'lt', value } };
+        case 'gte':
+            return { [field]: { __qast_operator__: 'gte', value } };
+        case 'lte':
+            return { [field]: { __qast_operator__: 'lte', value } };
+        case 'in':
+            return { [field]: { __qast_operator__: 'in', value } };
+        case 'contains':
+            // Sequelize uses Op.like for contains with wildcards
+            return { [field]: { __qast_operator__: 'contains', value } };
+        default:
+            throw new Error(`Unsupported operator: ${op}`);
+    }
+}
+/**
+ * Transform a logical node to Sequelize format
+ *
+ * Sequelize uses Op.and and Op.or for logical operations.
+ * Since we cannot import Op, we return metadata that indicates the logical operation.
+ *
+ * Users need to transform: { __qast_logical__: 'and', conditions: [...] }
+ * to: { [Op.and]: [...] }
+ */
+function transformLogicalNode(node) {
+    const leftFilter = transformNode(node.left);
+    const rightFilter = transformNode(node.right);
+    // Handle nested logical operations
+    // Check if either side already has logical operation metadata
+    const leftLogical = leftFilter.__qast_logical__;
+    const rightLogical = rightFilter.__qast_logical__;
+    if (node.type === 'AND') {
+        // For AND, combine conditions
+        if (leftLogical === 'and' && rightLogical === 'and') {
+            // Both have AND, merge their conditions
+            const leftConditions = leftFilter.conditions;
+            const rightConditions = rightFilter.conditions;
+            return {
+                __qast_logical__: 'and',
+                conditions: [...leftConditions, ...rightConditions],
+            };
+        }
+        else if (leftLogical === 'and') {
+            // Left has AND, add right to it
+            const leftConditions = leftFilter.conditions;
+            return {
+                __qast_logical__: 'and',
+                conditions: [...leftConditions, rightFilter],
+            };
+        }
+        else if (rightLogical === 'and') {
+            // Right has AND, add left to it
+            const rightConditions = rightFilter.conditions;
+            return {
+                __qast_logical__: 'and',
+                conditions: [leftFilter, ...rightConditions],
+            };
+        }
+        else {
+            // Neither has AND, create new AND array
+            return {
+                __qast_logical__: 'and',
+                conditions: [leftFilter, rightFilter],
+            };
+        }
+    }
+    else {
+        // For OR, combine conditions
+        if (leftLogical === 'or' && rightLogical === 'or') {
+            // Both have OR, merge their conditions
+            const leftConditions = leftFilter.conditions;
+            const rightConditions = rightFilter.conditions;
+            return {
+                __qast_logical__: 'or',
+                conditions: [...leftConditions, ...rightConditions],
+            };
+        }
+        else if (leftLogical === 'or') {
+            // Left has OR, add right to it
+            const leftConditions = leftFilter.conditions;
+            return {
+                __qast_logical__: 'or',
+                conditions: [...leftConditions, rightFilter],
+            };
+        }
+        else if (rightLogical === 'or') {
+            // Right has OR, add left to it
+            const rightConditions = rightFilter.conditions;
+            return {
+                __qast_logical__: 'or',
+                conditions: [leftFilter, ...rightConditions],
+            };
+        }
+        else {
+            // Neither has OR, create new OR array
+            return {
+                __qast_logical__: 'or',
+                conditions: [leftFilter, rightFilter],
+            };
+        }
+    }
+}
+//# sourceMappingURL=sequelize.js.map

package/dist/adapters/sequelize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequelize.js","sourceRoot":"","sources":["../../src/adapters/sequelize.ts"],"names":[],"mappings":"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"}

package/dist/adapters/typeorm.d.ts

@@ -0,0 +1,18 @@
+import { QastNode } from '../types/ast';
+/**
+ * TypeORM filter type
+ * Note: This returns a plain object that can be used with TypeORM's FindOptions
+ * In practice, TypeORM users may need to import operators from 'typeorm'
+ */
+export type TypeORMFilter = {
+    where: Record<string, any> | Array<Record<string, any>>;
+};
+/**
+ * Transform a QAST AST node to a TypeORM filter
+ *
+ * Note: TypeORM uses operator functions like MoreThan(), LessThan(), etc.
+ * This adapter returns a structure that can be used with TypeORM's FindOptions.
+ * For production use, users may need to wrap values with TypeORM operators.
+ */
+export declare function toTypeORMFilter(ast: QastNode): TypeORMFilter;
+//# sourceMappingURL=typeorm.d.ts.map

package/dist/adapters/typeorm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.d.ts","sourceRoot":"","sources":["../../src/adapters/typeorm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgE,MAAM,cAAc,CAAC;AAEtG;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;CACzD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,aAAa,CAG5D"}

package/dist/adapters/typeorm.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTypeORMFilter = toTypeORMFilter;
+const ast_1 = require("../types/ast");
+/**
+ * Transform a QAST AST node to a TypeORM filter
+ *
+ * Note: TypeORM uses operator functions like MoreThan(), LessThan(), etc.
+ * This adapter returns a structure that can be used with TypeORM's FindOptions.
+ * For production use, users may need to wrap values with TypeORM operators.
+ */
+function toTypeORMFilter(ast) {
+    const where = transformNode(ast);
+    return { where };
+}
+/**
+ * Transform a node to TypeORM format
+ */
+function transformNode(node) {
+    if ((0, ast_1.isComparisonNode)(node)) {
+        return transformComparisonNode(node);
+    }
+    else if ((0, ast_1.isLogicalNode)(node)) {
+        return transformLogicalNode(node);
+    }
+    throw new Error('Invalid node type');
+}
+/**
+ * Transform a comparison node to TypeORM format
+ *
+ * TypeORM uses operator functions from 'typeorm' package.
+ * Since we don't want to import TypeORM directly (optional peer dependency),
+ * we return a structure with metadata that can be used to build TypeORM FindOptions.
+ *
+ * For simple equality (eq), TypeORM accepts plain values.
+ * For other operators, users should use TypeORM operators like MoreThan(), LessThan(), etc.
+ *
+ * This function returns an object with an __qast_operator__ property that indicates
+ * the operator type. Users can transform this to use TypeORM operators.
+ */
+function transformComparisonNode(node) {
+    const { field, op, value } = node;
+    // Map operators to TypeORM-compatible format
+    // For eq, use direct value (TypeORM supports this)
+    // For other operators, include metadata for transformation
+    switch (op) {
+        case 'eq':
+            // Direct equality - TypeORM accepts this
+            return { [field]: value };
+        case 'ne':
+            // Not equal - requires Not(Equal(value)) from TypeORM
+            return { [field]: { __qast_operator__: 'ne', value } };
+        case 'gt':
+            // More than - requires MoreThan(value) from TypeORM
+            return { [field]: { __qast_operator__: 'gt', value } };
+        case 'lt':
+            // Less than - requires LessThan(value) from TypeORM
+            return { [field]: { __qast_operator__: 'lt', value } };
+        case 'gte':
+            // More than or equal - requires MoreThanOrEqual(value) from TypeORM
+            return { [field]: { __qast_operator__: 'gte', value } };
+        case 'lte':
+            // Less than or equal - requires LessThanOrEqual(value) from TypeORM
+            return { [field]: { __qast_operator__: 'lte', value } };
+        case 'in':
+            // In array - requires In(value) from TypeORM
+            return { [field]: { __qast_operator__: 'in', value } };
+        case 'contains':
+            // Contains (like) - requires Like(`%${value}%`) from TypeORM
+            return { [field]: { __qast_operator__: 'contains', value } };
+        default:
+            throw new Error(`Unsupported operator: ${op}`);
+    }
+}
+/**
+ * Transform a logical node to TypeORM format
+ *
+ * TypeORM handles AND/OR differently:
+ * - AND: Multiple conditions in same object (merged)
+ * - OR: Array of condition objects
+ */
+function transformLogicalNode(node) {
+    const leftFilter = transformNode(node.left);
+    const rightFilter = transformNode(node.right);
+    if (node.type === 'AND') {
+        // For AND, merge the filters into a single object
+        return mergeFilters(leftFilter, rightFilter);
+    }
+    else {
+        // For OR, create an array of conditions
+        const leftArray = Array.isArray(leftFilter) ? leftFilter : [leftFilter];
+        const rightArray = Array.isArray(rightFilter) ? rightFilter : [rightFilter];
+        return [...leftArray, ...rightArray];
+    }
+}
+/**
+ * Merge two TypeORM filters (for AND operations)
+ */
+function mergeFilters(left, right) {
+    // If either is an array, we need to flatten
+    // For AND operations in TypeORM, we merge objects
+    if (Array.isArray(left) || Array.isArray(right)) {
+        // If we have arrays in AND, we need to create a cartesian product
+        // For simplicity, we'll flatten and merge
+        const leftObj = Array.isArray(left) ? Object.assign({}, ...left) : left;
+        const rightObj = Array.isArray(right) ? Object.assign({}, ...right) : right;
+        return { ...leftObj, ...rightObj };
+    }
+    // Both are objects, merge them
+    return { ...left, ...right };
+}
+//# sourceMappingURL=typeorm.js.map

package/dist/adapters/typeorm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.js","sourceRoot":"","sources":["../../src/adapters/typeorm.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Base error class for QAST library
+ */
+export declare class QastError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown during tokenization when an invalid token is encountered
+ */
+export declare class TokenizationError extends QastError {
+    readonly position: number;
+    readonly query: string;
+    constructor(message: string, position: number, query: string);
+    /**
+     * Get a snippet of the query around the error position
+     */
+    getSnippet(): string;
+}
+/**
+ * Error thrown during parsing when the query syntax is invalid
+ */
+export declare class ParseError extends QastError {
+    readonly position: number;
+    readonly query: string;
+    constructor(message: string, position?: number, query?: string);
+}
+/**
+ * Error thrown during validation when a field or operator is not allowed
+ */
+export declare class ValidationError extends QastError {
+    readonly field?: string;
+    readonly operator?: string;
+    constructor(message: string, field?: string, operator?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;gBACtB,OAAO,EAAE,MAAM;CAK5B;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,KAAK,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAO5D;;OAEG;IACH,UAAU,IAAI,MAAM;CAOrB;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,SAAS;IACvC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,KAAK,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAM/D;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,SAAgB,KAAK,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAgB,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAEtB,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAM/D"}

package/dist/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationError = exports.ParseError = exports.TokenizationError = exports.QastError = void 0;
+/**
+ * Base error class for QAST library
+ */
+class QastError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.QastError = QastError;
+/**
+ * Error thrown during tokenization when an invalid token is encountered
+ */
+class TokenizationError extends QastError {
+    constructor(message, position, query) {
+        super(`${message} at position ${position}`);
+        this.position = position;
+        this.query = query;
+        this.name = 'TokenizationError';
+    }
+    /**
+     * Get a snippet of the query around the error position
+     */
+    getSnippet() {
+        const start = Math.max(0, this.position - 10);
+        const end = Math.min(this.query.length, this.position + 10);
+        const before = this.query.substring(start, this.position);
+        const after = this.query.substring(this.position, end);
+        return `${before}[ERROR]${after}`;
+    }
+}
+exports.TokenizationError = TokenizationError;
+/**
+ * Error thrown during parsing when the query syntax is invalid
+ */
+class ParseError extends QastError {
+    constructor(message, position, query) {
+        super(message);
+        this.position = position ?? -1;
+        this.query = query ?? '';
+        this.name = 'ParseError';
+    }
+}
+exports.ParseError = ParseError;
+/**
+ * Error thrown during validation when a field or operator is not allowed
+ */
+class ValidationError extends QastError {
+    constructor(message, field, operator) {
+        super(message);
+        this.field = field;
+        this.operator = operator;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,MAAa,SAAU,SAAQ,KAAK;IAClC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QAClC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAND,8BAMC;AAED;;GAEG;AACH,MAAa,iBAAkB,SAAQ,SAAS;IAI9C,YAAY,OAAe,EAAE,QAAgB,EAAE,KAAa;QAC1D,KAAK,CAAC,GAAG,OAAO,gBAAgB,QAAQ,EAAE,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,UAAU;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QACvD,OAAO,GAAG,MAAM,UAAU,KAAK,EAAE,CAAC;IACpC,CAAC;CACF;AArBD,8CAqBC;AAED;;GAEG;AACH,MAAa,UAAW,SAAQ,SAAS;IAIvC,YAAY,OAAe,EAAE,QAAiB,EAAE,KAAc;QAC5D,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,QAAQ,GAAG,QAAQ,IAAI,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;IAC3B,CAAC;CACF;AAVD,gCAUC;AAED;;GAEG;AACH,MAAa,eAAgB,SAAQ,SAAS;IAI5C,YAAY,OAAe,EAAE,KAAc,EAAE,QAAiB;QAC5D,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AAVD,0CAUC"}

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * QAST - Query to AST to ORM
+ *
+ * A library that parses human-readable query strings into ASTs
+ * and transforms them into ORM-compatible filter objects.
+ */
+export { parseQueryString } from './parser/parser';
+export { Tokenizer, Token, TokenType } from './parser/tokenizer';
+export { validateQuery, extractFields, extractOperators } from './parser/validator';
+export { toPrismaFilter, PrismaFilter } from './adapters/prisma';
+export { toTypeORMFilter, TypeORMFilter } from './adapters/typeorm';
+export { toSequelizeFilter, SequelizeFilter } from './adapters/sequelize';
+export { QastNode, ComparisonNode, LogicalNode, LogicalOperator, Operator, QastValue, ParseOptions, WhitelistOptions, isComparisonNode, isLogicalNode, } from './types/ast';
+export { QastError, ParseError, ValidationError, TokenizationError, } from './errors';
+import { ParseOptions, QastNode } from './types/ast';
+/**
+ * Parse a query string into an AST
+ *
+ * @param query - The query string to parse (e.g., 'age gt 25 and name eq "John"')
+ * @param options - Optional parsing options (whitelisting, validation)
+ * @returns The parsed AST node
+ *
+ * @example
+ * ```ts
+ * const ast = parseQuery('age gt 25 and name eq "John"');
+ * ```
+ *
+ * @example
+ * ```ts
+ * const ast = parseQuery('age gt 25', {
+ *   allowedFields: ['age', 'name'],
+ *   allowedOperators: ['gt', 'eq'],
+ *   validate: true,
+ * });
+ * ```
+ */
+export declare function parseQuery(query: string, options?: ParseOptions): QastNode;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGpF,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG1E,OAAO,EACL,QAAQ,EACR,cAAc,EACd,WAAW,EACX,eAAe,EACf,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,GACd,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,SAAS,EACT,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAKlB,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAoB,MAAM,aAAa,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,QAAQ,CAiB1E"}

package/dist/index.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * QAST - Query to AST to ORM
+ *
+ * A library that parses human-readable query strings into ASTs
+ * and transforms them into ORM-compatible filter objects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenizationError = exports.ValidationError = exports.ParseError = exports.QastError = exports.isLogicalNode = exports.isComparisonNode = exports.toSequelizeFilter = exports.toTypeORMFilter = exports.toPrismaFilter = exports.extractOperators = exports.extractFields = exports.validateQuery = exports.TokenType = exports.Tokenizer = exports.parseQueryString = void 0;
+exports.parseQuery = parseQuery;
+// Export parser
+var parser_1 = require("./parser/parser");
+Object.defineProperty(exports, "parseQueryString", { enumerable: true, get: function () { return parser_1.parseQueryString; } });
+var tokenizer_1 = require("./parser/tokenizer");
+Object.defineProperty(exports, "Tokenizer", { enumerable: true, get: function () { return tokenizer_1.Tokenizer; } });
+Object.defineProperty(exports, "TokenType", { enumerable: true, get: function () { return tokenizer_1.TokenType; } });
+// Export validators
+var validator_1 = require("./parser/validator");
+Object.defineProperty(exports, "validateQuery", { enumerable: true, get: function () { return validator_1.validateQuery; } });
+Object.defineProperty(exports, "extractFields", { enumerable: true, get: function () { return validator_1.extractFields; } });
+Object.defineProperty(exports, "extractOperators", { enumerable: true, get: function () { return validator_1.extractOperators; } });
+// Export adapters
+var prisma_1 = require("./adapters/prisma");
+Object.defineProperty(exports, "toPrismaFilter", { enumerable: true, get: function () { return prisma_1.toPrismaFilter; } });
+var typeorm_1 = require("./adapters/typeorm");
+Object.defineProperty(exports, "toTypeORMFilter", { enumerable: true, get: function () { return typeorm_1.toTypeORMFilter; } });
+var sequelize_1 = require("./adapters/sequelize");
+Object.defineProperty(exports, "toSequelizeFilter", { enumerable: true, get: function () { return sequelize_1.toSequelizeFilter; } });
+// Export types
+var ast_1 = require("./types/ast");
+Object.defineProperty(exports, "isComparisonNode", { enumerable: true, get: function () { return ast_1.isComparisonNode; } });
+Object.defineProperty(exports, "isLogicalNode", { enumerable: true, get: function () { return ast_1.isLogicalNode; } });
+// Export errors
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "QastError", { enumerable: true, get: function () { return errors_1.QastError; } });
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "TokenizationError", { enumerable: true, get: function () { return errors_1.TokenizationError; } });
+// Main parse function with options
+const parser_2 = require("./parser/parser");
+const validator_2 = require("./parser/validator");
+/**
+ * Parse a query string into an AST
+ *
+ * @param query - The query string to parse (e.g., 'age gt 25 and name eq "John"')
+ * @param options - Optional parsing options (whitelisting, validation)
+ * @returns The parsed AST node
+ *
+ * @example
+ * ```ts
+ * const ast = parseQuery('age gt 25 and name eq "John"');
+ * ```
+ *
+ * @example
+ * ```ts
+ * const ast = parseQuery('age gt 25', {
+ *   allowedFields: ['age', 'name'],
+ *   allowedOperators: ['gt', 'eq'],
+ *   validate: true,
+ * });
+ * ```
+ */
+function parseQuery(query, options) {
+    const ast = (0, parser_2.parseQueryString)(query);
+    // Validate if options are provided and validation is enabled
+    if (options && options.validate !== false) {
+        const whitelist = {
+            allowedFields: options.allowedFields,
+            allowedOperators: options.allowedOperators,
+        };
+        // Only validate if whitelists are provided
+        if (whitelist.allowedFields || whitelist.allowedOperators) {
+            (0, validator_2.validateQuery)(ast, whitelist);
+        }
+    }
+    return ast;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AA8DH,gCAiBC;AA7ED,gBAAgB;AAChB,0CAAmD;AAA1C,0GAAA,gBAAgB,OAAA;AACzB,gDAAiE;AAAxD,sGAAA,SAAS,OAAA;AAAS,sGAAA,SAAS,OAAA;AAEpC,oBAAoB;AACpB,gDAAoF;AAA3E,0GAAA,aAAa,OAAA;AAAE,0GAAA,aAAa,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAEvD,kBAAkB;AAClB,4CAAiE;AAAxD,wGAAA,cAAc,OAAA;AACvB,8CAAoE;AAA3D,0GAAA,eAAe,OAAA;AACxB,kDAA0E;AAAjE,8GAAA,iBAAiB,OAAA;AAE1B,eAAe;AACf,mCAWqB;AAFnB,uGAAA,gBAAgB,OAAA;AAChB,oGAAA,aAAa,OAAA;AAGf,gBAAgB;AAChB,mCAKkB;AAJhB,mGAAA,SAAS,OAAA;AACT,oGAAA,UAAU,OAAA;AACV,yGAAA,eAAe,OAAA;AACf,2GAAA,iBAAiB,OAAA;AAGnB,mCAAmC;AACnC,4CAAmD;AACnD,kDAAmD;AAGnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,UAAU,CAAC,KAAa,EAAE,OAAsB;IAC9D,MAAM,GAAG,GAAG,IAAA,yBAAgB,EAAC,KAAK,CAAC,CAAC;IAEpC,6DAA6D;IAC7D,IAAI,OAAO,IAAI,OAAO,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;QAC1C,MAAM,SAAS,GAAqB;YAClC,aAAa,EAAE,OAAO,CAAC,aAAa;YACpC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;SAC3C,CAAC;QAEF,2CAA2C;QAC3C,IAAI,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,gBAAgB,EAAE,CAAC;YAC1D,IAAA,yBAAa,EAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/parser/parser.d.ts

@@ -0,0 +1,49 @@
+import { Token } from './tokenizer';
+import { QastNode } from '../types/ast';
+/**
+ * Parser for QAST query strings
+ * Grammar:
+ *   expression -> term (("and" | "or") term)*
+ *   term -> factor | "(" expression ")"
+ *   factor -> IDENTIFIER OPERATOR VALUE
+ */
+export declare class Parser {
+    private tokens;
+    private position;
+    private currentToken;
+    constructor(tokens: Token[]);
+    /**
+     * Advance to the next token
+     */
+    private advance;
+    /**
+     * Expect a token of a specific type, throw error if not found
+     */
+    private expect;
+    /**
+     * Check if current token matches a type
+     */
+    private check;
+    /**
+     * Parse a factor: IDENTIFIER OPERATOR VALUE
+     */
+    private parseFactor;
+    /**
+     * Parse a term: factor | "(" expression ")"
+     */
+    private parseTerm;
+    /**
+     * Parse an expression: term (("and" | "or") term)*
+     * Left-associative: a and b or c is parsed as (a and b) or c
+     */
+    private parseExpression;
+    /**
+     * Parse the query and return the AST
+     */
+    parse(): QastNode;
+}
+/**
+ * Parse a query string into an AST
+ */
+export declare function parseQueryString(query: string): QastNode;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/parser/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,EAAa,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAA4B,MAAM,cAAc,CAAC;AAGlE;;;;;;GAMG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAQ;gBAEhB,MAAM,EAAE,KAAK,EAAE;IAM3B;;OAEG;IACH,OAAO,CAAC,OAAO;IASf;;OAEG;IACH,OAAO,CAAC,MAAM;IAYd;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,OAAO,CAAC,WAAW;IAoCnB;;OAEG;IACH,OAAO,CAAC,SAAS;IAajB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAyBvB;;OAEG;IACI,KAAK,IAAI,QAAQ;CAmBzB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAYxD"}