@mst003/milql 1.1.1

package/.github/copilot-instructions.md

@@ -0,0 +1,37 @@
+<!-- Use this file to provide workspace-specific custom instructions to Copilot. For more details, visit https://code.visualstudio.com/docs/copilot/copilot-customization#_use-a-githubcopilotinstructionsmd-file -->
+- [x] Verify that the copilot-instructions.md file in the .github directory is created. - File created successfully.
+
+- [x] Clarify Project Requirements - Node.js npm package project for refactoring a plugin specified.
+
+- [x] Scaffold the Project
+	<!--
+	Ensure that the previous step has been marked as completed.
+	Call project setup tool with projectType parameter.
+	Run scaffolding command to create project files and folders.
+	Use '.' as the working directory.
+	If no appropriate projectType is available, search documentation using available tools.
+	Otherwise, create the project structure manually using available file creation tools.
+	-->
+	- Created package.json, index.js, README.md, .gitignore manually.
+
+- [x] Customize the Project
+	- Plugin logic ported from Java/Groovy to Node.js, ANTLR grammars adapted for JS, classes implemented in lib/
+
+- [x] Install Required Extensions
+	- No extensions needed.
+
+- [x] Compile the Project
+	- No compilation required for Node.js project.
+
+- [x] Create and Run Task
+	- No tasks required.
+
+- [x] Launch the Project
+	- Not applicable for npm package.
+
+- [x] Ensure Documentation is Complete
+	- README.md created, HTML comments removed from copilot-instructions.md.
+
+- Work through each checklist item systematically.
+- Keep communication concise and focused.
+- Follow development best practices.

package/.gitlab-ci.yml

@@ -0,0 +1,29 @@
+stages:
+  #- test
+  - publish
+
+variables:
+  NPM_REGISTRY: "https://gitlab.com/api/v4/projects/$CI_PROJECT_ID/packages/npm/"
+
+cache:
+  paths:
+    - node_modules/
+
+# test:
+#   image: node:20
+#   stage: test
+#   script:
+#     - npm ci
+#     - npm test
+
+publish:
+  image: node:20
+  stage: publish
+  script:
+    - echo "Publishing package to GitLab NPM registry..."
+    - npm config set //gitlab.com/api/v4/projects/$CI_PROJECT_ID/packages/npm/:_authToken $GROUP_REGISTRY_TOKEN
+    - npm publish --registry "$NPM_REGISTRY"
+  rules:
+    - if: '$CI_COMMIT_TAG'
+      when: always
+    - when: never

package/README.md

@@ -0,0 +1,37 @@
+# mil-ql
+
+An implementation of the MIL Query Language for Node.js.
+
+## Installation
+
+```bash
+npm install mil-ql
+```
+
+## Setup
+
+This package includes a built-in MILQL parser, so no ANTLR file generation is required.
+
+## Usage
+
+```javascript
+const { Parser, HQLTransform } = require('mil-ql');
+
+const hql = new HQLTransform('Entity');
+Parser.parse('filters=name::eq::"Alice"&sort=-createdAt&limit=10', hql);
+
+console.log(hql.query);
+console.log(hql.parameters);
+```
+
+## API
+
+- `HQLTransform(entityName)`: Creates an HQL transformer for the given entity.
+- `BaseASTListener`: Base class for implementing AST listeners.
+- `ASTListener`: Interface for AST listeners.
+- `Operator`: Enum for filter operators.
+- `SortDirection`: Enum for sort directions.
+
+## License
+
+ISC

package/index.js

@@ -0,0 +1,18 @@
+// Main entry point for the mil-ql npm package
+// MIL Query Language implementation for Node.js
+
+const HQLTransform = require('./lib/HQLTransform');
+const BaseASTListener = require('./lib/BaseASTListener');
+const ASTListener = require('./lib/ASTListener');
+const Operator = require('./lib/Operator');
+const SortDirection = require('./lib/SortDirection');
+const Parser = require('./lib/Parser');
+
+module.exports = {
+  HQLTransform,
+  BaseASTListener,
+  ASTListener,
+  Operator,
+  SortDirection,
+  Parser
+};

package/lib/ASTListener.js

@@ -0,0 +1,51 @@
+class ASTListener {
+  enterLimit() {}
+  exitLimit(value) {}
+
+  enterOffset() {}
+  exitOffset(value) {}
+
+  enterSort() {}
+  exitSort() {}
+  enterSortTerm() {}
+  exitSortTerm(sortDirection, sortKey) {}
+
+  enterFullTextSearch() {}
+  exitFullTextSearch(searchString) {}
+
+  enterEmbedPath() {}
+  exitEmbedPath() {}
+  enterEmbedDepth() {}
+  exitEmbedDepth() {}
+  enterEmbedPathExpression() {}
+  exitEmbedPathExpression(path) {}
+
+  enterDepthExpression() {}
+  exitDepthExpression(value) {}
+
+  enterFilter() {}
+  exitFilter() {}
+  enterAndPredicate() {}
+  exitAndPredicate() {}
+  enterOrPredicate() {}
+  exitOrPredicate() {}
+  enterPredicateTerm() {}
+  exitPredicateTerm(operator, lhs) {}
+  enterPredicateRightIntegerOperand() {}
+  exitPredicateRightIntegerOperand(value) {}
+  enterPredicateRightDecimalOperand() {}
+  exitPredicateRightDecimalOperand(value) {}
+  enterPredicateRightDateOperand() {}
+  exitPredicateRightDateOperand(value) {}
+  enterPredicateRightBlankOperand() {}
+  exitPredicateRightBlankOperand() {}
+  enterPredicateRightStringOperand() {}
+  exitPredicateRightStringOperand(value) {}
+
+  enterField() {}
+  exitField() {}
+  enterFieldTerm() {}
+  exitFieldTerm(fieldKey) {}
+}
+
+module.exports = ASTListener;

package/lib/BaseASTListener.js

@@ -0,0 +1,7 @@
+const ASTListener = require('./ASTListener');
+
+class BaseASTListener extends ASTListener {
+  // All methods are empty as in the base
+}
+
+module.exports = BaseASTListener;

package/lib/HQLTransform.js

@@ -0,0 +1,206 @@
+const BaseASTListener = require('./BaseASTListener');
+const SortDirection = require('./SortDirection');
+const Operator = require('./Operator');
+
+class HQLTransform extends BaseASTListener {
+  static ENTITY_ALIAS = 'e';
+
+  constructor(entity) {
+    super();
+    this.limit = 25;
+    this.offset = 0;
+    this.selectClause = "";
+    this.joinClause = "";
+    this.orderByClause = "";
+    this.whereClause = "";
+    this.parameters = {};
+    this.entity = entity;
+
+    this.orderByTerms = [];
+    this.selectTerms = [];
+    this.joinTerms = [];
+    this.predicates = [];
+    this.operands = [];
+    this.parameterId = 1;
+  }
+
+  getRecordParser() {
+    // TODO: implement HQLRecordParser
+    // return new HQLRecordParser(this.selectTerms);
+  }
+
+  get query() {
+    return `SELECT * FROM ${this.entity} ${HQLTransform.ENTITY_ALIAS} ${this.joinClause} ${this.whereClause} ${this.orderByClause}`;
+  }
+
+  get countQuery() {
+    return `select count(*) from ${this.entity} ${HQLTransform.ENTITY_ALIAS} ${this.whereClause}`;
+  }
+
+  // Pagination parsing
+
+  exitLimit(value) {
+    this.limit = value;
+  }
+
+  exitOffset(value) {
+    this.offset = value;
+  }
+
+  // Ordering parsing
+
+  exitSort() {
+    this.orderByClause = `order by ${this.orderByTerms.join(', ')}`;
+  }
+
+  exitSortTerm(sortDirection, sortKey) {
+    this.orderByTerms.push(`${sortKey.join('.')} ${this.asHQLSortDirection(sortDirection)}`);
+  }
+
+  // Projection parsing
+
+  exitField() {
+    this.selectClause = `select ${this.selectTerms.map(term => `${HQLTransform.ENTITY_ALIAS}.${term.join('.')}`).join(', ')}`;
+  }
+
+  exitFieldTerm(fieldTerm) {
+    this.selectTerms.push(fieldTerm);
+  }
+
+  // Embed parsing
+
+  exitEmbedPath() {
+    if (this.joinTerms.length > 0) {
+      this.joinClause = this.joinTerms.map(term => `left join fetch ${HQLTransform.ENTITY_ALIAS}.${term.join('.')}`).join(' ');
+    }
+  }
+
+  exitEmbedPathExpression(path) {
+    this.joinTerms.push(path);
+  }
+
+  // Filtering parsing
+
+  exitFilter() {
+    this.whereClause = `where ${this.predicates.pop()}`;
+  }
+
+  exitAndPredicate() {
+    const rhs = this.predicates.pop();
+    const lhs = this.predicates.pop();
+    this.predicates.push(`(${lhs} and ${rhs})`);
+  }
+
+  exitOrPredicate() {
+    const rhs = this.predicates.pop();
+    const lhs = this.predicates.pop();
+    this.predicates.push(`(${lhs} or ${rhs})`);
+  }
+
+  exitPredicateTerm(operator, lhs) {
+    const rhs = this.operands.pop();
+    const paramName = rhs.slice(1);
+    this.applyOperatorParameter(operator, paramName);
+
+    const fieldExpression = this.asHQLExpression(operator, lhs.join('.'));
+    this.predicates.push(`(${fieldExpression} ${this.asHQLOperator(operator)} ${rhs})`);
+  }
+
+  exitPredicateRightIntegerOperand(value) {
+    this.addParameter(value);
+  }
+
+  exitPredicateRightDecimalOperand(value) {
+    this.addParameter(value);
+  }
+
+  exitPredicateRightDateOperand(value) {
+    this.addParameter(value);
+  }
+
+  exitPredicateRightBlankOperand() {
+    this.addParameter(null);
+  }
+
+  exitPredicateRightStringOperand(value) {
+    this.addParameter(value);
+  }
+
+  addParameter(value) {
+    const paramName = `param_${this.parameterId++}`;
+    this.parameters[paramName] = value;
+    this.operands.push(`:${paramName}`);
+    return paramName;
+  }
+
+  applyOperatorParameter(operator, paramName) {
+    let value = this.parameters[paramName];
+    if (value == null) {
+      return;
+    }
+
+    switch (operator) {
+      case Operator.CONTAINS_SUBSTRING:
+      case Operator.NOT_CONTAINS_SUBSTRING:
+        value = `%${value}%`;
+        break;
+      case Operator.STARTS_WITH:
+      case Operator.STARTS_WITH_LOWCASE_IGNOREACCENT:        
+        value = `${value}%`;        
+        break;
+      case Operator.ENDS_WITH:
+        value = `%${value}`;
+        break;
+      case Operator.EQUALS_WITH_LOWCASE_IGNOREACCENT:
+        value = `${value}`.toLowerCase();
+        break;
+      case Operator.STARTS_WITH_LOWCASE_IGNOREACCENT:
+        value = `${value}`.toLowerCase();
+        break;
+      default:
+        break;
+    }
+
+    this.parameters[paramName] = value;
+  }
+
+  asHQLExpression(operator, field) {
+    switch (operator) {
+      case Operator.EQUALS_WITH_LOWCASE_IGNOREACCENT:
+      case Operator.STARTS_WITH_LOWCASE_IGNOREACCENT:
+        return `lower(${field})`;
+      default:
+        return field;
+    }
+  }
+
+  asHQLSortDirection(sortDirection) {
+    switch (sortDirection) {
+      case SortDirection.DESC: return 'desc';
+      case SortDirection.ASC: return 'asc';
+      default: throw new Error("Invalid sort direction");
+    }
+  }
+
+  asHQLOperator(operator) {
+    switch (operator) {
+      case Operator.EQUALS: return '=';
+      case Operator.NOT_EQUALS: return '!=';
+      case Operator.GREATER_THAN: return '>';
+      case Operator.GREATER_OR_EQUAL_TO: return '>=';
+      case Operator.LESS_THAN: return '<';
+      case Operator.LESS_THAN_OR_EQUAL_TO: return '<=';
+      case Operator.CONTAINS_SUBSTRING: return 'like';
+      case Operator.NOT_CONTAINS_SUBSTRING: return 'not like';
+      case Operator.STARTS_WITH: return 'like';
+      case Operator.ENDS_WITH: return 'like';
+      case Operator.STARTS_WITH_LOWCASE_IGNOREACCENT: return 'like';
+      case Operator.EQUALS_WITH_LOWCASE_IGNOREACCENT: return '=';
+      case Operator.MATCHES_REGEX: return 'regexp';
+      case Operator.NOT_MATCHES_REGEX: return 'not regexp';
+      default: throw new Error('Unsupported operator.');
+    }
+  }
+}
+
+module.exports = HQLTransform;

package/lib/Operator.js

@@ -0,0 +1,27 @@
+const Operator = {
+  EQUALS: 'eq',
+  NOT_EQUALS: 'neq',
+  GREATER_THAN: 'gt',
+  GREATER_OR_EQUAL_TO: 'gte',
+  LESS_THAN: 'lt',
+  LESS_THAN_OR_EQUAL_TO: 'lte',
+  CONTAINS_SUBSTRING: 'ct',
+  NOT_CONTAINS_SUBSTRING: 'nct',
+  STARTS_WITH: 'sw',
+  ENDS_WITH: 'ew',
+  MATCHES_REGEX: 'mre',
+  NOT_MATCHES_REGEX: 'nmre',
+  STARTS_WITH_LOWCASE_IGNOREACCENT: 'swlcia',
+  EQUALS_WITH_LOWCASE_IGNOREACCENT: 'eqlcia'
+};
+
+Operator.from = function(test) {
+  for (let key in Operator) {
+    if (Operator[key] === test) {
+      return key;
+    }
+  }
+  return null;
+};
+
+module.exports = Operator;

package/lib/Parser.js

@@ -0,0 +1,278 @@
+const Operator = require('./Operator');
+const SortDirection = require('./SortDirection');
+
+const OPERATOR_MAP = {
+  eq: Operator.EQUALS,
+  neq: Operator.NOT_EQUALS,
+  gt: Operator.GREATER_THAN,
+  gte: Operator.GREATER_OR_EQUAL_TO,
+  lt: Operator.LESS_THAN,
+  lte: Operator.LESS_THAN_OR_EQUAL_TO,
+  ct: Operator.CONTAINS_SUBSTRING,
+  nct: Operator.NOT_CONTAINS_SUBSTRING,
+  sw: Operator.STARTS_WITH,
+  ew: Operator.ENDS_WITH,
+  mre: Operator.MATCHES_REGEX,
+  nmre: Operator.NOT_MATCHES_REGEX,
+  swlcia: Operator.STARTS_WITH_LOWCASE_IGNOREACCENT,
+  eqlcia: Operator.EQUALS_WITH_LOWCASE_IGNOREACCENT
+};
+
+class Parser {
+  static parse(input, astListener) {
+    const query = input.startsWith('?') ? input.slice(1) : input;
+    const params = new URLSearchParams(query);
+
+    for (const [name, value] of params) {
+      switch (name) {
+        case 'limit':
+          astListener.enterLimit();
+          astListener.exitLimit(parseInt(value, 10));
+          break;
+        case 'offset':
+          astListener.enterOffset();
+          astListener.exitOffset(parseInt(value, 10));
+          break;
+        case 'sort':
+          Parser.parseSort(value, astListener);
+          break;
+        case 'fields':
+          Parser.parseFields(value, astListener);
+          break;
+        case 'embed':
+          Parser.parseEmbed(value, astListener);
+          break;
+        case 'filters':
+          Parser.parseFilters(value, astListener);
+          break;
+        case 'q':
+          astListener.enterFullTextSearch();
+          astListener.exitFullTextSearch(value);
+          break;
+        default:
+          break;
+      }
+    }
+
+    return astListener;
+  }
+
+  static parseSort(value, astListener) {
+    astListener.enterSort();
+    const terms = value.split(',').filter(Boolean);
+    for (const term of terms) {
+      astListener.enterSortTerm();
+      const direction = term.startsWith('-') ? SortDirection.DESC : SortDirection.ASC;
+      const path = term.replace(/^-/, '').split('.').filter(Boolean);
+      astListener.exitSortTerm(direction, path);
+    }
+    astListener.exitSort();
+  }
+
+  static parseFields(value, astListener) {
+    astListener.enterField();
+    const fields = value.split(',').filter(Boolean);
+    for (const field of fields) {
+      const path = field.split('.').filter(Boolean);
+      astListener.enterFieldTerm();
+      astListener.exitFieldTerm(path);
+    }
+    astListener.exitField();
+  }
+
+  static parseEmbed(value, astListener) {
+    astListener.enterEmbedPath();
+    const paths = value.split(',').filter(Boolean);
+    for (const pathText of paths) {
+      const path = pathText.split('.').filter(Boolean);
+      astListener.enterEmbedPathExpression();
+      astListener.exitEmbedPathExpression(path);
+    }
+    astListener.exitEmbedPath();
+  }
+
+  static parseFilters(value, astListener) {
+    astListener.enterFilter();
+    const tokens = Parser.tokenizeFilter(value);
+    const ast = Parser.parseFilterExpression(tokens);
+    Parser.walkFilter(ast, astListener);
+    astListener.exitFilter();
+  }
+
+  static tokenizeFilter(value) {
+    const tokens = [];
+    let text = value.trim();
+
+    while (text.length > 0) {
+      if (text.startsWith('(')) {
+        tokens.push({ type: 'lparen' });
+        text = text.slice(1).trimStart();
+        continue;
+      }
+      if (text.startsWith(')')) {
+        tokens.push({ type: 'rparen' });
+        text = text.slice(1).trimStart();
+        continue;
+      }
+      if (text.startsWith(';')) {
+        tokens.push({ type: 'and' });
+        text = text.slice(1).trimStart();
+        continue;
+      }
+      if (text.startsWith(',')) {
+        tokens.push({ type: 'or' });
+        text = text.slice(1).trimStart();
+        continue;
+      }
+
+      const operatorMatch = text.match(/^([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)*)::(eq|neq|gt|gte|lt|lte|ct|nct|sw|ew|mre|nmre|eqlcia|swlcia)::/);
+      if (operatorMatch) {
+        tokens.push({ type: 'term', lhs: operatorMatch[1].split('.'), operator: operatorMatch[2] });
+        text = text.slice(operatorMatch[0].length).trimStart();
+        continue;
+      }
+
+      const blankMatch = text.match(/^BLANK\b/);
+      if (blankMatch) {
+        tokens.push({ type: 'blank' });
+        text = text.slice(blankMatch[0].length).trimStart();
+        continue;
+      }
+
+      const quotedMatch = text.match(/^"([^"\\]*(?:\\.[^"\\]*)*)"/);
+      if (quotedMatch) {
+        tokens.push({ type: 'string', value: quotedMatch[1].replace(/\\"/g, '"') });
+        text = text.slice(quotedMatch[0].length).trimStart();
+        continue;
+      }
+
+      const numberMatch = text.match(/^([0-9]+(?:\.[0-9]+)?)/);
+      if (numberMatch) {
+        tokens.push({ type: 'number', value: numberMatch[1] });
+        text = text.slice(numberMatch[0].length).trimStart();
+        continue;
+      }
+
+      throw new Error(`Unable to parse filters near: ${text}`);
+    }
+
+    return tokens;
+  }
+
+  static parseFilterExpression(tokens, minPrec = 0) {
+    let node = Parser.parseFilterPrimary(tokens);
+
+    while (tokens.length > 0 && Parser.getPrecedence(tokens[0]) >= minPrec) {
+      const opToken = tokens.shift();
+      const precedence = Parser.getPrecedence(opToken);
+      const nextMinPrec = precedence + 1;
+      const rhs = Parser.parseFilterExpression(tokens, nextMinPrec);
+      node = { type: opToken.type, left: node, right: rhs };
+    }
+
+    return node;
+  }
+
+  static parseFilterPrimary(tokens) {
+    const token = tokens.shift();
+    if (!token) {
+      throw new Error('Unexpected end of filter expression');
+    }
+
+    if (token.type === 'lparen') {
+      const node = Parser.parseFilterExpression(tokens);
+      const next = tokens.shift();
+      if (!next || next.type !== 'rparen') {
+        throw new Error('Missing closing parenthesis in filter expression');
+      }
+      return node;
+    }
+
+    if (token.type === 'term') {
+      const rhs = Parser.parseFilterValue(tokens);
+      return {
+        type: 'term',
+        lhs: token.lhs,
+        operator: token.operator,
+        rhs
+      };
+    }
+
+    throw new Error(`Unexpected token in filter expression: ${JSON.stringify(token)}`);
+  }
+
+  static parseFilterValue(tokens) {
+    const token = tokens.shift();
+    if (!token) {
+      throw new Error('Filter value expected');
+    }
+
+    if (token.type === 'blank') {
+      return { type: 'blank', value: null };
+    }
+    if (token.type === 'string') {
+      const dateValue = /^\d{4}-\d{2}-\d{2}$/.test(token.value) ? new Date(token.value) : token.value;
+      return { type: dateValue instanceof Date ? 'date' : 'string', value: dateValue };
+    }
+    if (token.type === 'number') {
+      return token.value.includes('.')
+        ? { type: 'decimal', value: parseFloat(token.value) }
+        : { type: 'integer', value: parseInt(token.value, 10) };
+    }
+
+    throw new Error(`Invalid filter value token: ${JSON.stringify(token)}`);
+  }
+
+  static getPrecedence(token) {
+    if (!token) return -1;
+    if (token.type === 'and') return 2;
+    if (token.type === 'or') return 1;
+    return -1;
+  }
+
+  static walkFilter(node, astListener) {
+    if (!node) return;
+
+    if (node.type === 'and') {
+      astListener.enterAndPredicate();
+      Parser.walkFilter(node.left, astListener);
+      Parser.walkFilter(node.right, astListener);
+      astListener.exitAndPredicate();
+      return;
+    }
+
+    if (node.type === 'or') {
+      astListener.enterOrPredicate();
+      Parser.walkFilter(node.left, astListener);
+      Parser.walkFilter(node.right, astListener);
+      astListener.exitOrPredicate();
+      return;
+    }
+
+    astListener.enterPredicateTerm();
+
+    if (node.rhs.type === 'integer') {
+      astListener.enterPredicateRightIntegerOperand();
+      astListener.exitPredicateRightIntegerOperand(node.rhs.value);
+    } else if (node.rhs.type === 'decimal') {
+      astListener.enterPredicateRightDecimalOperand();
+      astListener.exitPredicateRightDecimalOperand(node.rhs.value);
+    } else if (node.rhs.type === 'date') {
+      astListener.enterPredicateRightDateOperand();
+      astListener.exitPredicateRightDateOperand(node.rhs.value);
+    } else if (node.rhs.type === 'blank') {
+      astListener.enterPredicateRightBlankOperand();
+      astListener.exitPredicateRightBlankOperand();
+    } else if (node.rhs.type === 'string') {
+      astListener.enterPredicateRightStringOperand();
+      astListener.exitPredicateRightStringOperand(node.rhs.value);
+    } else {
+      throw new Error(`Unsupported filter rhs type: ${node.rhs.type}`);
+    }
+
+    astListener.exitPredicateTerm(OPERATOR_MAP[node.operator], node.lhs);
+  }
+}
+
+
+module.exports = Parser;

package/lib/SortDirection.js

@@ -0,0 +1,6 @@
+const SortDirection = {
+  DESC: 'DESC',
+  ASC: 'ASC'
+};
+
+module.exports = SortDirection;

package/lib/internal/CSTListener.js

@@ -0,0 +1,97 @@
+const antlr4 = require('antlr4');
+
+class CSTListener extends require('../MILQLParserListener') {
+  constructor(astListener) {
+    super();
+    this.astListener = astListener;
+  }
+
+  // Limit
+  enterLimitParameter(ctx) {
+    this.astListener.enterLimit();
+  }
+  exitLimitParameter(ctx) {
+    this.astListener.exitLimit(this.asInteger(ctx.Integer));
+  }
+
+  // Offset
+  enterOffsetParameter(ctx) {
+    this.astListener.enterOffset();
+  }
+  exitOffsetParameter(ctx) {
+    this.astListener.exitOffset(this.asInteger(ctx.Integer));
+  }
+
+  // Sort
+  enterSortParameter(ctx) {
+    this.astListener.enterSort();
+  }
+  exitSortParameter(ctx) {
+    this.astListener.exitSort();
+  }
+  enterSortExpression(ctx) {
+    this.astListener.enterSortTerm();
+  }
+  sortIdentifierPath = [];
+  enterSortIdentifierPath(ctx) {
+    this.sortIdentifierPath = [];
+  }
+  exitSortIdentifierStep(ctx) {
+    this.sortIdentifierPath.push(this.decode(ctx.SortIdentifier.getText()));
+  }
+  exitSortExpression(ctx) {
+    const direction = ctx.ReverseSort ? require('../SortDirection').DESC : require('../SortDirection').ASC;
+    this.astListener.exitSortTerm(direction, [...this.sortIdentifierPath]);
+  }
+
+  // Field
+  enterFieldParameter(ctx) {
+    this.astListener.enterField();
+  }
+  exitFieldParameter(ctx) {
+    this.astListener.exitField();
+  }
+  enterFieldExpression(ctx) {
+    this.astListener.enterFieldTerm();
+  }
+  fieldIdentifierPath = [];
+  enterFieldIdentifierPath(ctx) {
+    this.fieldIdentifierPath = [];
+  }
+  exitFieldIdentifierStep(ctx) {
+    this.fieldIdentifierPath.push(this.decode(ctx.FieldIdentifier.getText()));
+  }
+  exitFieldExpression(ctx) {
+    this.astListener.exitFieldTerm([...this.fieldIdentifierPath]);
+  }
+
+  // Embed
+  exitEmbedPathExpression(ctx) {
+    // Collect path - simplified
+    const path = []; // TODO: implement path collection
+    this.astListener.exitEmbedPathExpression(path);
+  }
+
+  // Filter - TODO: implement complex filter parsing
+  exitFilter(ctx) {
+    this.astListener.exitFilter();
+  }
+
+  // Search
+  enterSearchParameter(ctx) {
+    this.astListener.enterFullTextSearch();
+  }
+  exitSearchParameter(ctx) {
+    this.astListener.exitFullTextSearch(this.decode(ctx.ParameterValue.getText()));
+  }
+
+  // Helpers
+  asInteger(token) {
+    return parseInt(token.getText());
+  }
+  decode(str) {
+    return decodeURIComponent(str);
+  }
+}
+
+module.exports = CSTListener;

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@mst003/milql",
+  "version": "1.1.1",
+  "description": "An implementation of the MIL Query Language for Node.js",
+  "main": "index.js",
+  "scripts": {
+    "test": "node tempTest.js"
+  },
+  "keywords": ["milql", "query", "language", "hql"],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+
+}

package/src/MILQLLexer.g

@@ -0,0 +1,203 @@
+lexer grammar MILQLLexer;
+
+// @header {
+// }
+
+// ----------------------------------------------------------------------------
+// mode default;
+
+Field
+  : 'fields' Equals -> pushMode(FieldMode)
+  ;
+
+Filter
+  : 'filters' Equals -> pushMode(FilterMode)
+  ;
+
+Embed
+  : 'embed' Equals -> pushMode(EmbedMode)
+  ;
+
+Limit
+  : 'limit' Equals
+  ;
+
+Offset
+  : 'offset' Equals
+  ;
+
+Search
+  : 'q' Equals
+  ;
+
+Sort
+  : 'sort' Equals -> pushMode(SortMode)
+  ;
+
+Equals
+  : '='
+  ;
+
+Ampersand
+  : '&'
+  ;
+
+Integer
+  : ( [0-9] )+ ( 'L' )?
+  ;
+
+Decimal
+  : ( [0-9] )+ '.' ( [0-9] )+ ( 'D' )?
+  ;
+
+Identifier
+  : ( [a-z] | [A-Z] | [0-9] | '_' )+
+  ;
+
+ParameterValue
+  : ( [a-z] | [A-Z] | [0-9]| ',' | '-' | '.' | '%' | '+' )+
+  ;
+
+// ----------------------------------------------------------------------------
+mode EmbedMode;
+
+Depth
+  : 'DEPTH.'
+  ;
+
+PathExpressionSeparator
+  : '%2C' | ','
+  ;
+
+PathStepSeparator
+  : '.'
+  ;
+
+DepthValue
+  : Integer
+  ;
+
+PathStepIdentifier
+  : Identifier
+  ;
+
+EndEmbedMode
+  : '&' -> popMode
+  ;
+
+// ----------------------------------------------------------------------------
+mode SortMode;
+
+ReverseSort
+  : '-'
+  ;
+
+SortExpressionSeparator
+  : '%2C' | ','
+  ;
+
+SortIdentifierStepSeparator
+  : '.'
+  ;
+
+SortIdentifier
+  : Identifier
+  ;
+
+EndSortMode
+  : '&' -> popMode
+  ;
+
+// ----------------------------------------------------------------------------
+mode FieldMode;
+
+FieldExpressionSeparator
+  : '%2C' | ','
+  ;
+
+FieldIdentifierStepSeparator
+  : '.'
+  ;
+
+EndFieldMode
+  : '&' -> popMode
+  ;
+
+FieldIdentifier
+  : Identifier
+  ;
+
+// ----------------------------------------------------------------------------
+mode FilterMode;
+
+AndFilter
+  : '%3B' | ';'
+  ;
+
+OrFilter
+  : '%2C' | ','
+  ;
+
+FilterOperation
+  : ('%3A%3A' | '::')
+    ( 'eq'
+    | 'neq'
+    | 'gt'
+    | 'gte'
+    | 'lt'
+    | 'lte'
+    | 'ct'
+    | 'nct'
+    | 'sw'
+    | 'ew'
+    | 'mre'
+    | 'nmre'
+    | 'eqlcia'
+    | 'swlcia'
+    )
+    ('%3A%3A' | '::')
+  ;
+
+FilterLeftParens
+  : '%28' | '('
+  ;
+
+FilterRightParens
+  : '%29' | ')'
+  ;
+
+FilterBlank
+  : 'BLANK'
+  ;
+
+FilterInteger
+  : Integer
+  ;
+
+FilterDecimal
+  : Decimal
+  ;
+
+FilterIdentifierStepSeparator
+  : '.'
+  ;
+
+FilterIdentifier
+  : Identifier
+  ;
+
+Digit
+  : [0-9]
+  ;
+
+HexDigit
+  : [0-9] | [A-F]
+  ;
+
+FilterDate
+  : '%22' Digit Digit Digit Digit '-' Digit Digit '-' Digit Digit '%22'
+  ;
+
+FilterString
+  : '"' ( ~'"' )* '"'
+  ;

package/src/MILQLParser.g

@@ -0,0 +1,102 @@
+parser grammar MILQLParser;
+
+options { tokenVocab=MILQLLexer; }
+
+// @header {
+// }
+
+parameterList
+  : ( parameter
+      ( ( Ampersand
+        | EndEmbedMode
+        | EndSortMode
+        | EndFilterMode
+        | EndFieldMode
+        )
+        parameter
+      )*
+    )?
+    EOF
+  ;
+
+parameter
+  : Embed pathExpressions   # EmbedPathParameter
+  | Embed depthExpression   # EmbedDepthParameter
+  | Field fieldExpressions  # FieldParameter
+  | Filter filterExpression # FilterParameter
+  | Limit Integer           # LimitParameter
+  | Offset Integer          # OffsetParameter
+  | Search ParameterValue   # SearchParameter
+  | Sort sortExpressions    # SortParameter
+  ;
+
+pathExpressions
+  : pathExpression ( PathExpressionSeparator pathExpression )*
+  ;
+
+pathExpression
+  : pathStepExpression ( PathStepSeparator pathStepExpression )*
+  ;
+
+pathStepExpression
+  : PathStepIdentifier
+  ;
+
+depthExpression
+  : Depth DepthValue
+  ;
+
+fieldExpressions
+  : fieldExpression ( FieldExpressionSeparator fieldExpression )*
+  ;
+
+fieldExpression
+  : fieldIdentifierPath
+  ;
+
+fieldIdentifierPath
+  : fieldIdentifierStep ( FieldIdentifierStepSeparator fieldIdentifierStep )*
+  ;
+
+fieldIdentifierStep
+  : FieldIdentifier
+  ;
+
+filterExpression
+  : filterExpression AndFilter filterExpression          # AndFilterExpression
+  | filterExpression OrFilter filterExpression           # OrFilterExpression
+  | filterIdentifierPath FilterOperation filterTestValue # FilterTermExpression
+  | FilterLeftParens filterExpression FilterRightParens  # FilterGroup
+  ;
+
+filterIdentifierPath
+  : filterIdentifierStep ( FilterIdentifierStepSeparator filterIdentifierStep )*
+  ;
+
+filterIdentifierStep
+  : FilterIdentifier
+  ;
+
+filterTestValue
+  : FilterInteger # FilterInteger
+  | FilterDecimal # FilterDecimal
+  | FilterDate    # FilterDate
+  | FilterBlank   # FilterBlank
+  | FilterString  # FilterString
+  ;
+
+sortExpressions
+  : sortExpression ( SortExpressionSeparator sortExpression )*
+  ;
+
+sortExpression
+  : ReverseSort? sortIdentifierPath
+  ;
+
+sortIdentifierPath
+  : sortIdentifierStep ( SortIdentifierStepSeparator sortIdentifierStep )*
+  ;
+
+sortIdentifierStep
+  : SortIdentifier
+  ;

package/tempTest.js

@@ -0,0 +1,6 @@
+const { Parser, HQLTransform } = require('./index');
+const hql = new HQLTransform('User');
+Parser.parse('filters=name::eq::"Alice"&sort=-createdAt&limit=10&offset=5&q=hello', hql);
+console.log(hql.query);
+console.log(JSON.stringify(hql.parameters));
+console.log(hql.limit, hql.offset);