qast 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 QAST Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,428 @@
+# QAST — Query to AST to ORM
+
+**QAST** is a small, ORM-agnostic library that parses human-readable query strings (e.g. `age gt 25 and (name eq "John" or city eq "Paris")`) into an **Abstract Syntax Tree (AST)** and then transforms that AST into **ORM-compatible filter objects** such as Prisma or TypeORM filters.
+
+It aims to provide a secure, declarative, and type-safe way to support advanced filtering in REST APIs — without falling into the pitfalls of raw string-based query patterns.
+
+## Features
+
+- 🔒 **Safe**: Validates operators, values, and fields against whitelists
+- 🎯 **Type-Safe**: Full TypeScript support for parsed ASTs and generated filters
+- 🔌 **ORM-Agnostic**: Works with Prisma, TypeORM, Sequelize, and more via adapters
+- 📝 **Simple Syntax**: Natural query expressions using logical operators
+- 🚀 **Lightweight**: No dependencies, small bundle size
+
+## Installation
+
+```bash
+npm install qast
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { parseQuery, toPrismaFilter } from 'qast';
+
+const query = 'age gt 25 and (name eq "John" or city eq "Paris")';
+
+const ast = parseQuery(query);
+const prismaFilter = toPrismaFilter(ast);
+
+await prisma.user.findMany(prismaFilter);
+```
+
+### With Validation
+
+```typescript
+import { parseQuery, toPrismaFilter } from 'qast';
+
+const query = 'age gt 25 and name eq "John"';
+
+// Parse with whitelist validation
+const ast = parseQuery(query, {
+  allowedFields: ['age', 'name', 'city'],
+  allowedOperators: ['gt', 'eq', 'lt'],
+  validate: true,
+});
+
+const prismaFilter = toPrismaFilter(ast);
+await prisma.user.findMany(prismaFilter);
+```
+
+## Query Syntax
+
+### Operators
+
+QAST supports the following comparison operators:
+
+- `eq` - Equal
+- `ne` - Not equal
+- `gt` - Greater than
+- `lt` - Less than
+- `gte` - Greater than or equal
+- `lte` - Less than or equal
+- `in` - In array
+- `contains` - Contains substring (string matching)
+
+### Logical Operators
+
+- `and` - Logical AND
+- `or` - Logical OR
+
+### Values
+
+- **Strings**: Use single or double quotes: `"John"` or `'John'`
+- **Numbers**: Integers or floats: `25`, `25.99`, `-10`
+- **Booleans**: `true` or `false`
+- **Arrays**: For `in` operator: `[1,2,3]` or `["John","Jane"]`
+
+### Examples
+
+```typescript
+// Simple comparison
+'age gt 25'
+
+// String comparison
+'name eq "John"'
+
+// Boolean comparison
+'active eq true'
+
+// Array (in operator)
+'age in [1,2,3]'
+
+// AND operation
+'age gt 25 and name eq "John"'
+
+// OR operation
+'name eq "John" or name eq "Jane"'
+
+// Nested parentheses
+'age gt 25 and (name eq "John" or city eq "Paris")'
+
+// Complex query
+'age gt 25 and (name eq "John" or city eq "Paris") and active eq true'
+```
+
+## ORM Adapters
+
+### Prisma
+
+```typescript
+import { parseQuery, toPrismaFilter } from 'qast';
+
+const query = 'age gt 25 and name eq "John"';
+const ast = parseQuery(query);
+const filter = toPrismaFilter(ast);
+
+// filter = {
+//   where: {
+//     age: { gt: 25 },
+//     name: { equals: "John" }
+//   }
+// }
+
+await prisma.user.findMany(filter);
+```
+
+### TypeORM
+
+```typescript
+import { parseQuery, toTypeORMFilter } from 'qast';
+import { MoreThan, Equal } from 'typeorm';
+
+const query = 'age gt 25 and name eq "John"';
+const ast = parseQuery(query);
+const filter = toTypeORMFilter(ast);
+
+// Note: TypeORM requires operator functions for non-equality comparisons
+// The adapter returns a structure that you can transform using TypeORM operators
+// For equality, TypeORM accepts plain values directly
+
+// filter.where = {
+//   age: { __qast_operator__: 'gt', value: 25 },
+//   name: "John"
+// }
+
+// Transform to use TypeORM operators:
+// const transformed = {
+//   age: MoreThan(25),
+//   name: "John"
+// }
+
+await userRepository.find({ where: transformed });
+```
+
+**Note**: TypeORM requires operator functions (`MoreThan`, `LessThan`, etc.) for non-equality comparisons. The adapter returns a structure with metadata that you can transform. For equality comparisons, TypeORM accepts plain values.
+
+### Sequelize
+
+```typescript
+import { parseQuery, toSequelizeFilter } from 'qast';
+import { Op } from 'sequelize';
+
+const query = 'age gt 25 and name eq "John"';
+const ast = parseQuery(query);
+const filter = toSequelizeFilter(ast);
+
+// filter = {
+//   __qast_logical__: 'and',
+//   conditions: [
+//     { age: { __qast_operator__: 'gt', value: 25 } },
+//     { name: 'John' }
+//   ]
+// }
+
+// Transform to use Sequelize Op operators:
+function transformSequelizeFilter(filter: any): any {
+  if (filter.__qast_logical__) {
+    const op = filter.__qast_logical__ === 'and' ? Op.and : Op.or;
+    return {
+      [op]: filter.conditions.map(transformSequelizeFilter),
+    };
+  }
+  
+  const result: any = {};
+  for (const [key, value] of Object.entries(filter)) {
+    if (value && typeof value === 'object' && '__qast_operator__' in value) {
+      const opKey = value.__qast_operator__;
+      const op = Op[opKey as keyof typeof Op];
+      if (opKey === 'contains') {
+        result[key] = { [Op.like]: `%${value.value}%` };
+      } else {
+        result[key] = { [op]: value.value };
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+const transformed = transformSequelizeFilter(filter);
+// transformed = {
+//   [Op.and]: [
+//     { age: { [Op.gt]: 25 } },
+//     { name: 'John' }
+//   ]
+// }
+
+await User.findAll({ where: transformed });
+```
+
+**Note**: Sequelize uses the `Op` object from 'sequelize'. Since Sequelize is an optional peer dependency, the adapter returns a structure with metadata (`__qast_operator__` and `__qast_logical__`) that you need to transform to use `Op` operators. For simple equality (`eq`), the adapter returns plain values which Sequelize accepts directly.
+
+## API Reference
+
+### `parseQuery(query: string, options?: ParseOptions): QastNode`
+
+Parse a query string into an AST.
+
+**Parameters:**
+- `query` - The query string to parse
+- `options` - Optional parsing options:
+  - `allowedFields?: string[]` - Whitelist of allowed field names
+  - `allowedOperators?: Operator[]` - Whitelist of allowed operators
+  - `validate?: boolean` - Whether to validate against whitelists (default: true if whitelists are provided)
+
+**Returns:** The parsed AST node
+
+**Example:**
+```typescript
+const ast = parseQuery('age gt 25', {
+  allowedFields: ['age', 'name'],
+  allowedOperators: ['gt', 'eq'],
+  validate: true,
+});
+```
+
+### `toPrismaFilter(ast: QastNode): PrismaFilter`
+
+Transform an AST to a Prisma filter.
+
+**Returns:** Prisma filter object with `where` property
+
+### `toTypeORMFilter(ast: QastNode): TypeORMFilter`
+
+Transform an AST to a TypeORM filter.
+
+**Returns:** TypeORM filter object with `where` property
+
+**Note:** TypeORM requires operator functions for non-equality comparisons. You may need to transform the result.
+
+### `toSequelizeFilter(ast: QastNode): SequelizeFilter`
+
+Transform an AST to a Sequelize filter.
+
+**Returns:** Sequelize filter object
+
+**Note:** Sequelize uses the `Op` object. You need to transform `$`-prefixed operators to use `Op` operators.
+
+### `validateQuery(ast: QastNode, whitelist: WhitelistOptions): void`
+
+Validate an AST against whitelists.
+
+**Parameters:**
+- `ast` - The AST to validate
+- `whitelist` - Whitelist options:
+  - `allowedFields?: string[]` - Allowed field names
+  - `allowedOperators?: Operator[]` - Allowed operators
+
+**Throws:** `ValidationError` if validation fails
+
+### `extractFields(ast: QastNode): string[]`
+
+Extract all field names used in an AST.
+
+**Returns:** Array of unique field names
+
+### `extractOperators(ast: QastNode): Operator[]`
+
+Extract all operators used in an AST.
+
+**Returns:** Array of unique operators
+
+## Security Best Practices
+
+1. **Always use whitelists**: Restrict which fields and operators can be used in queries.
+
+```typescript
+const ast = parseQuery(req.query.filter, {
+  allowedFields: ['age', 'name', 'city'],
+  allowedOperators: ['gt', 'eq', 'lt'],
+  validate: true,
+});
+```
+
+2. **Validate user input**: Don't trust user-provided query strings without validation.
+
+3. **Limit query complexity**: Consider limiting the depth of nested queries to prevent DoS attacks.
+
+4. **Use type checking**: Ensure values match expected types for fields.
+
+## Error Handling
+
+QAST provides custom error classes:
+
+- `ParseError` - Syntax errors in query strings
+- `ValidationError` - Validation failures (disallowed fields/operators)
+- `TokenizationError` - Tokenization errors
+
+```typescript
+import { parseQuery, ParseError, ValidationError } from 'qast';
+
+try {
+  const ast = parseQuery(query, { allowedFields: ['age'], validate: true });
+} catch (error) {
+  if (error instanceof ParseError) {
+    console.error('Parse error:', error.message);
+  } else if (error instanceof ValidationError) {
+    console.error('Validation error:', error.message);
+    console.error('Field:', error.field);
+    console.error('Operator:', error.operator);
+  }
+}
+```
+
+## TypeScript Support
+
+QAST is written in TypeScript and provides full type definitions:
+
+```typescript
+import { QastNode, ComparisonNode, LogicalNode, Operator } from 'qast';
+
+function processNode(node: QastNode): void {
+  if (node.type === 'COMPARISON') {
+    const comparison = node as ComparisonNode;
+    console.log(comparison.field, comparison.op, comparison.value);
+  } else if (node.type === 'AND' || node.type === 'OR') {
+    const logical = node as LogicalNode;
+    processNode(logical.left);
+    processNode(logical.right);
+  }
+}
+```
+
+## Examples
+
+### REST API Endpoint
+
+```typescript
+import { parseQuery, toPrismaFilter } from 'qast';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+app.get('/users', async (req, res) => {
+  try {
+    const query = req.query.filter as string;
+    
+    // Parse and validate query
+    const ast = parseQuery(query, {
+      allowedFields: ['age', 'name', 'city', 'active'],
+      allowedOperators: ['gt', 'lt', 'eq', 'in'],
+      validate: true,
+    });
+    
+    // Transform to Prisma filter
+    const filter = toPrismaFilter(ast);
+    
+    // Query database
+    const users = await prisma.user.findMany(filter);
+    
+    res.json(users);
+  } catch (error) {
+    if (error instanceof ValidationError) {
+      res.status(400).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: 'Internal server error' });
+    }
+  }
+});
+```
+
+### Express Middleware
+
+```typescript
+import { parseQuery, toPrismaFilter, ValidationError } from 'qast';
+
+function qastMiddleware(allowedFields: string[], allowedOperators: Operator[]) {
+  return (req, res, next) => {
+    try {
+      if (req.query.filter) {
+        const ast = parseQuery(req.query.filter, {
+          allowedFields,
+          allowedOperators,
+          validate: true,
+        });
+        
+        req.qastFilter = toPrismaFilter(ast);
+      }
+      next();
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        res.status(400).json({ error: error.message });
+      } else {
+        next(error);
+      }
+    }
+  };
+}
+```
+
+## License
+
+MIT © 2025
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+- GitHub Repository: https://github.com/hocestnonsatis/qast
+- Issues: https://github.com/hocestnonsatis/qast/issues
+
+## Acknowledgments
+
+QAST is inspired by the need for safe, type-safe query parsing in REST APIs. It aims to provide a lightweight alternative to complex query protocols while maintaining security and developer experience.

package/dist/adapters/prisma.d.ts

@@ -0,0 +1,12 @@
+import { QastNode } from '../types/ast';
+/**
+ * Prisma filter type
+ */
+export type PrismaFilter = {
+    where: Record<string, any>;
+};
+/**
+ * Transform a QAST AST node to a Prisma filter
+ */
+export declare function toPrismaFilter(ast: QastNode): PrismaFilter;
+//# sourceMappingURL=prisma.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../src/adapters/prisma.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgE,MAAM,cAAc,CAAC;AAEtG;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,YAAY,CAI1D"}

package/dist/adapters/prisma.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPrismaFilter = toPrismaFilter;
+const ast_1 = require("../types/ast");
+/**
+ * Transform a QAST AST node to a Prisma filter
+ */
+function toPrismaFilter(ast) {
+    return {
+        where: transformNode(ast),
+    };
+}
+/**
+ * Transform a node to Prisma 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 Prisma format
+ */
+function transformComparisonNode(node) {
+    const { field, op, value } = node;
+    // Map operators to Prisma operators
+    switch (op) {
+        case 'eq':
+            return { [field]: { equals: value } };
+        case 'ne':
+            return { [field]: { not: value } };
+        case 'gt':
+            return { [field]: { gt: value } };
+        case 'lt':
+            return { [field]: { lt: value } };
+        case 'gte':
+            return { [field]: { gte: value } };
+        case 'lte':
+            return { [field]: { lte: value } };
+        case 'in':
+            return { [field]: { in: value } };
+        case 'contains':
+            return { [field]: { contains: value } };
+        default:
+            throw new Error(`Unsupported operator: ${op}`);
+    }
+}
+/**
+ * Transform a logical node to Prisma format
+ */
+function transformLogicalNode(node) {
+    const leftFilter = transformNode(node.left);
+    const rightFilter = transformNode(node.right);
+    if (node.type === 'AND') {
+        // For AND, merge the filters
+        return mergeFilters(leftFilter, rightFilter);
+    }
+    else {
+        // For OR, create an OR array
+        // If either side already has an OR, we need to flatten
+        const leftOr = leftFilter.OR;
+        const rightOr = rightFilter.OR;
+        if (leftOr && rightOr) {
+            // Both have OR arrays, combine them
+            return {
+                OR: [...leftOr, ...rightOr],
+            };
+        }
+        else if (leftOr) {
+            // Left has OR, add right to it
+            return {
+                OR: [...leftOr, rightFilter],
+            };
+        }
+        else if (rightOr) {
+            // Right has OR, add left to it
+            return {
+                OR: [leftFilter, ...rightOr],
+            };
+        }
+        else {
+            // Neither has OR, create new OR array
+            return {
+                OR: [leftFilter, rightFilter],
+            };
+        }
+    }
+}
+/**
+ * Merge two Prisma filters (for AND operations)
+ */
+function mergeFilters(left, right) {
+    const result = { ...left };
+    // Handle OR arrays - if both have OR, we need to combine them properly
+    // For AND with OR, Prisma requires: { field: value, OR: [...] }
+    if (left.OR || right.OR) {
+        // If both sides have OR, we need to distribute
+        // This is complex - for now, we'll merge non-OR fields and keep OR separate
+        const leftOr = left.OR;
+        const rightOr = right.OR;
+        // Remove OR from both objects
+        const leftWithoutOr = { ...left };
+        const rightWithoutOr = { ...right };
+        delete leftWithoutOr.OR;
+        delete rightWithoutOr.OR;
+        // Merge non-OR fields
+        Object.assign(result, leftWithoutOr);
+        Object.assign(result, rightWithoutOr);
+        // Handle OR arrays - in Prisma, when ANDing with OR, we need to be careful
+        if (leftOr && rightOr) {
+            // This is complex - we'll create nested conditions
+            // For simplicity, we'll merge all fields and combine ORs
+            result.OR = [...(leftOr || []), ...(rightOr || [])];
+        }
+        else if (leftOr) {
+            result.OR = leftOr;
+        }
+        else if (rightOr) {
+            result.OR = rightOr;
+        }
+    }
+    else {
+        // Simple merge - combine all fields
+        Object.assign(result, right);
+    }
+    return result;
+}
+//# sourceMappingURL=prisma.js.map

package/dist/adapters/prisma.js.map

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

package/dist/adapters/sequelize.d.ts

@@ -0,0 +1,37 @@
+import { QastNode } from '../types/ast';
+/**
+ * Sequelize filter type
+ *
+ * Note: Sequelize uses the Op object from 'sequelize' package for operators.
+ * Since Sequelize is an optional peer dependency, we cannot import Op directly.
+ *
+ * This adapter returns a structure that represents the query logic, but you need
+ * to transform it to use Sequelize's Op operators.
+ *
+ * For simple equality, Sequelize accepts plain values: { age: 25 }
+ * For other operators, you need Op: { age: { [Op.gt]: 25 } }
+ * For logical operations, you need Op.and/Op.or: { [Op.and]: [...] }
+ */
+export type SequelizeFilter = Record<string, any>;
+/**
+ * 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.
+ */
+export declare function toSequelizeFilter(ast: QastNode): SequelizeFilter;
+//# sourceMappingURL=sequelize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequelize.d.ts","sourceRoot":"","sources":["../../src/adapters/sequelize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgE,MAAM,cAAc,CAAC;AAEtG;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAElD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,GAAG,eAAe,CAEhE"}