@shaxpir/squilt 1.0.0

package/dist/renderer/QueryRenderer.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteIdentifier = quoteIdentifier;
+exports.shouldQuoteIdentifier = shouldQuoteIdentifier;
+// Comprehensive list of SQLite reserved keywords (case-insensitive)
+const RESERVED_KEYWORDS = new Set([
+    'ABORT', 'ACTION', 'ADD', 'AFTER', 'ALL', 'ALTER', 'ALWAYS', 'ANALYZE', 'AND',
+    'AS', 'ASC', 'ATTACH', 'AUTOINCREMENT', 'BEFORE', 'BEGIN', 'BETWEEN', 'BY',
+    'CASCADE', 'CASE', 'CAST', 'CHECK', 'COLLATE', 'COLUMN', 'COMMIT', 'CONFLICT',
+    'CONSTRAINT', 'CREATE', 'CROSS', 'CURRENT', 'CURRENT_DATE', 'CURRENT_TIME',
+    'CURRENT_TIMESTAMP', 'DATABASE', 'DEFAULT', 'DEFERRED', 'DEFERRABLE', 'DELETE',
+    'DESC', 'DETACH', 'DISTINCT', 'DO', 'DROP', 'EACH', 'ELSE', 'END', 'ESCAPE',
+    'EXCEPT', 'EXCLUDE', 'EXCLUSIVE', 'EXISTS', 'EXPLAIN', 'FAIL', 'FILTER', 'FIRST',
+    'FOLLOWING', 'FOR', 'FOREIGN', 'FROM', 'FULL', 'GENERATED', 'GLOB', 'GROUP',
+    'GROUPS', 'HAVING', 'IF', 'IGNORE', 'IMMEDIATE', 'IN', 'INDEX', 'INDEXED',
+    'INITIALLY', 'INNER', 'INSERT', 'INSTEAD', 'INTERSECT', 'INTO', 'IS', 'ISNULL',
+    'JOIN', 'KEY', 'LAST', 'LEFT', 'LIKE', 'LIMIT', 'MATCH', 'MATERIALIZED', 'NATURAL',
+    'NO', 'NOT', 'NOTHING', 'NOTNULL', 'NULL', 'NULLS', 'OF', 'OFFSET', 'ON', 'OR',
+    'ORDER', 'OTHERS', 'OUTER', 'OVER', 'PARTITION', 'PLAN', 'PRAGMA', 'PRECEDING',
+    'PRIMARY', 'QUERY', 'RAISE', 'RANGE', 'RECURSIVE', 'REFERENCES', 'REGEXP',
+    'REINDEX', 'RELEASE', 'RENAME', 'REPLACE', 'RESTRICT', 'RETURNING', 'RIGHT',
+    'ROLLBACK', 'ROW', 'ROWS', 'SAVEPOINT', 'SELECT', 'SET', 'TABLE', 'TEMP',
+    'TEMPORARY', 'THEN', 'TIES', 'TO', 'TRANSACTION', 'TRIGGER', 'UNBOUNDED',
+    'UNION', 'UNIQUE', 'UPDATE', 'USING', 'VACUUM', 'VALUES', 'VIEW', 'VIRTUAL',
+    'WHEN', 'WHERE', 'WINDOW', 'WITH', 'WITHOUT'
+]);
+// Utility function to quote identifiers, escaping inner quotes
+function quoteIdentifier(identifier) {
+    if (identifier === '*') {
+        return identifier; // Do not quote '*'
+    }
+    // Handle database-qualified identifiers (e.g., "database.table")
+    if (identifier.includes('.')) {
+        const parts = identifier.split('.');
+        if (parts.length === 2) {
+            // Quote each part individually if needed (except for asterisk), then join with dot
+            const quotedParts = parts.map(part => {
+                if (part === '*') {
+                    return part; // Don't quote asterisk
+                }
+                return shouldQuoteIdentifier(part) ? `"${part.replace(/"/g, '""')}"` : part;
+            });
+            return quotedParts.join('.');
+        }
+    }
+    if (shouldQuoteIdentifier(identifier)) {
+        // Escape double-quotes by doubling them (e.g., " becomes "")
+        const escaped = identifier.replace(/"/g, '""');
+        return `"${escaped}"`;
+    }
+    return identifier; // Return unquoted if no quoting is needed
+}
+function shouldQuoteIdentifier(identifier) {
+    // Check for empty or invalid input
+    if (!identifier || identifier.trim() === '') {
+        return true; // Empty or invalid identifiers should be quoted to avoid errors
+    }
+    // Check if the identifier is a reserved keyword (case-insensitive)
+    if (RESERVED_KEYWORDS.has(identifier.toUpperCase())) {
+        return true;
+    }
+    // Check if the identifier contains special characters or spaces
+    // Valid unquoted identifiers: letters, digits, underscores; must not start with a digit
+    const validIdentifierPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!validIdentifierPattern.test(identifier)) {
+        return true;
+    }
+    // Check for case sensitivity (if identifier has uppercase letters)
+    // SQLite is case-insensitive by default, but quoting preserves case
+    const hasUpperCase = /[A-Z]/.test(identifier);
+    if (hasUpperCase) {
+        return true; // Quote if case sensitivity is desired
+    }
+    // No quotes needed for simple, lowercase, non-reserved identifiers
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QueryRenderer.js","sourceRoot":"","sources":["../../src/renderer/QueryRenderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { InsertQuery } from \"../ast/InsertQuery\";\nimport { SelectQuery } from \"../ast/SelectQuery\";\nimport { SqlTreeNodeVisitor } from \"../visitor/SqlTreeNodeVisitor\";\n\n\n// Comprehensive list of SQLite reserved keywords (case-insensitive)\nconst RESERVED_KEYWORDS = new Set([\n  'ABORT', 'ACTION', 'ADD', 'AFTER', 'ALL', 'ALTER', 'ALWAYS', 'ANALYZE', 'AND',\n  'AS', 'ASC', 'ATTACH', 'AUTOINCREMENT', 'BEFORE', 'BEGIN', 'BETWEEN', 'BY',\n  'CASCADE', 'CASE', 'CAST', 'CHECK', 'COLLATE', 'COLUMN', 'COMMIT', 'CONFLICT',\n  'CONSTRAINT', 'CREATE', 'CROSS', 'CURRENT', 'CURRENT_DATE', 'CURRENT_TIME',\n  'CURRENT_TIMESTAMP', 'DATABASE', 'DEFAULT', 'DEFERRED', 'DEFERRABLE', 'DELETE',\n  'DESC', 'DETACH', 'DISTINCT', 'DO', 'DROP', 'EACH', 'ELSE', 'END', 'ESCAPE',\n  'EXCEPT', 'EXCLUDE', 'EXCLUSIVE', 'EXISTS', 'EXPLAIN', 'FAIL', 'FILTER', 'FIRST',\n  'FOLLOWING', 'FOR', 'FOREIGN', 'FROM', 'FULL', 'GENERATED', 'GLOB', 'GROUP',\n  'GROUPS', 'HAVING', 'IF', 'IGNORE', 'IMMEDIATE', 'IN', 'INDEX', 'INDEXED',\n  'INITIALLY', 'INNER', 'INSERT', 'INSTEAD', 'INTERSECT', 'INTO', 'IS', 'ISNULL',\n  'JOIN', 'KEY', 'LAST', 'LEFT', 'LIKE', 'LIMIT', 'MATCH', 'MATERIALIZED', 'NATURAL',\n  'NO', 'NOT', 'NOTHING', 'NOTNULL', 'NULL', 'NULLS', 'OF', 'OFFSET', 'ON', 'OR',\n  'ORDER', 'OTHERS', 'OUTER', 'OVER', 'PARTITION', 'PLAN', 'PRAGMA', 'PRECEDING',\n  'PRIMARY', 'QUERY', 'RAISE', 'RANGE', 'RECURSIVE', 'REFERENCES', 'REGEXP',\n  'REINDEX', 'RELEASE', 'RENAME', 'REPLACE', 'RESTRICT', 'RETURNING', 'RIGHT',\n  'ROLLBACK', 'ROW', 'ROWS', 'SAVEPOINT', 'SELECT', 'SET', 'TABLE', 'TEMP',\n  'TEMPORARY', 'THEN', 'TIES', 'TO', 'TRANSACTION', 'TRIGGER', 'UNBOUNDED',\n  'UNION', 'UNIQUE', 'UPDATE', 'USING', 'VACUUM', 'VALUES', 'VIEW', 'VIRTUAL',\n  'WHEN', 'WHERE', 'WINDOW', 'WITH', 'WITHOUT'\n]);\n\n// Utility function to quote identifiers, escaping inner quotes\nexport function quoteIdentifier(identifier: string): string {\n  if (identifier === '*') {\n    return identifier; // Do not quote '*'\n  }\n\n  // Handle database-qualified identifiers (e.g., \"database.table\")\n  if (identifier.includes('.')) {\n    const parts = identifier.split('.');\n    if (parts.length === 2) {\n      // Quote each part individually if needed (except for asterisk), then join with dot\n      const quotedParts = parts.map(part => {\n        if (part === '*') {\n          return part; // Don't quote asterisk\n        }\n        return shouldQuoteIdentifier(part) ? `\"${part.replace(/\"/g, '\"\"')}\"` : part;\n      });\n      return quotedParts.join('.');\n    }\n  }\n\n  if (shouldQuoteIdentifier(identifier)) {\n    // Escape double-quotes by doubling them (e.g., \" becomes \"\")\n    const escaped = identifier.replace(/\"/g, '\"\"');\n    return `\"${escaped}\"`;\n  }\n  return identifier; // Return unquoted if no quoting is needed\n}\n\nexport interface QueryRenderer extends SqlTreeNodeVisitor<string> {\n  render(node: SelectQuery | InsertQuery): string;\n}\n\nexport function shouldQuoteIdentifier(identifier: string): boolean {\n  // Check for empty or invalid input\n  if (!identifier || identifier.trim() === '') {\n    return true; // Empty or invalid identifiers should be quoted to avoid errors\n  }\n\n  // Check if the identifier is a reserved keyword (case-insensitive)\n  if (RESERVED_KEYWORDS.has(identifier.toUpperCase())) {\n      return true;\n  }\n\n  // Check if the identifier contains special characters or spaces\n  // Valid unquoted identifiers: letters, digits, underscores; must not start with a digit\n  const validIdentifierPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\n  if (!validIdentifierPattern.test(identifier)) {\n      return true;\n  }\n\n  // Check for case sensitivity (if identifier has uppercase letters)\n  // SQLite is case-insensitive by default, but quoting preserves case\n  const hasUpperCase = /[A-Z]/.test(identifier);\n  if (hasUpperCase) {\n      return true; // Quote if case sensitivity is desired\n  }\n\n  // No quotes needed for simple, lowercase, non-reserved identifiers\n  return false;\n}\n"]}

package/dist/validate/CommonQueryValidator.d.ts

@@ -0,0 +1,50 @@
+import { AliasableExpression } from "../ast/Abstractions";
+import { Alias } from "../ast/Alias";
+import { BinaryExpression } from "../ast/BinaryExpression";
+import { CaseExpression } from "../ast/CaseExpression";
+import { Column } from "../ast/Column";
+import { Concat } from "../ast/Concat";
+import { ExistsExpression } from "../ast/ExistsExpression";
+import { From, JsonEachFrom, SubqueryFrom, TableFrom } from "../ast/From";
+import { FunctionExpression } from "../ast/FunctionExpression";
+import { InExpression } from "../ast/InExpression";
+import { InsertQuery } from "../ast/InsertQuery";
+import { Join } from "../ast/Join";
+import { NullLiteral, NumberLiteral, Param, StringLiteral } from "../ast/Literals";
+import { OrderBy } from "../ast/OrderBy";
+import { SelectQuery } from "../ast/SelectQuery";
+import { UnaryExpression } from "../ast/UnaryExpression";
+import { With } from "../ast/With";
+import { ColumnLikeVisitorAcceptor, FromLikeAndJoinVisitorAcceptor, SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { QueryValidator } from "./QueryValidator";
+export declare class CommonQueryValidator implements QueryValidator, SqlTreeNodeVisitor<void> {
+    protected fromLikeAndJoinAcceptor: FromLikeAndJoinVisitorAcceptor<void>;
+    protected columnLikeAcceptor: ColumnLikeVisitorAcceptor<void>;
+    private columnCount;
+    private isGrouped;
+    validate(query: SelectQuery | InsertQuery): void;
+    protected reset(): void;
+    private validateAlias;
+    private validateIdentifier;
+    visitInsertQuery(node: InsertQuery): void;
+    visitSelectQuery(node: SelectQuery): void;
+    visitTableFrom(node: TableFrom): void;
+    visitSubqueryFrom(node: SubqueryFrom): void;
+    visitJsonEachFrom(node: JsonEachFrom): void;
+    visitColumn(node: Column): void;
+    visitAlias(node: Alias<From | AliasableExpression>): void;
+    visitJoinClause(node: Join): void;
+    visitOrderBy(node: OrderBy): void;
+    visitWithClause(node: With): void;
+    visitBinaryExpression(node: BinaryExpression): void;
+    visitUnaryExpression(node: UnaryExpression): void;
+    visitInExpression(node: InExpression): void;
+    visitConcat(node: Concat): void;
+    visitCaseExpression(node: CaseExpression): void;
+    visitFunctionExpression(node: FunctionExpression): void;
+    visitParamExpression(_node: Param): void;
+    visitStringLiteral(node: StringLiteral): void;
+    visitNumberLiteral(node: NumberLiteral): void;
+    visitNullLiteral(_node: NullLiteral): void;
+    visitExistsExpression(node: ExistsExpression): void;
+}

package/dist/validate/CommonQueryValidator.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonQueryValidator = void 0;
+const Abstractions_1 = require("../ast/Abstractions");
+const Column_1 = require("../ast/Column");
+const From_1 = require("../ast/From");
+const Join_1 = require("../ast/Join");
+const SelectQuery_1 = require("../ast/SelectQuery");
+const SqlTreeNodeVisitor_1 = require("../visitor/SqlTreeNodeVisitor");
+const RESERVED_KEYWORDS = new Set([
+    'SELECT', 'FROM', 'WHERE', 'JOIN', 'ON', 'GROUP', 'BY', 'HAVING', 'UNION',
+    'ORDER', 'LIMIT', 'OFFSET', 'TABLE', 'INDEX', 'VIEW', 'TRIGGER', 'KEY',
+    'COLUMN', 'CONSTRAINT', 'PRIMARY', 'FOREIGN', 'CHECK', 'DEFAULT', 'NULL',
+    'NOT', 'AND', 'OR', 'LIKE', 'IN', 'IS', 'BETWEEN', 'CASE', 'WHEN', 'THEN',
+    'ELSE', 'END', 'INSERT', 'INTO', 'VALUES', 'EXISTS'
+]);
+class CommonQueryValidator {
+    constructor() {
+        this.fromLikeAndJoinAcceptor = new SqlTreeNodeVisitor_1.FromLikeAndJoinVisitorAcceptor();
+        this.columnLikeAcceptor = new SqlTreeNodeVisitor_1.ColumnLikeVisitorAcceptor();
+        this.columnCount = null;
+        this.isGrouped = false;
+    }
+    validate(query) {
+        this.reset();
+        query.accept(this);
+    }
+    reset() {
+        this.columnCount = null;
+        this.isGrouped = false;
+    }
+    validateAlias(alias, context) {
+        if (alias && !alias.trim()) {
+            throw new Error(`Empty alias in ${context}`);
+        }
+        if (alias && RESERVED_KEYWORDS.has(alias.toUpperCase())) {
+            throw new Error(`Alias '${alias}' in ${context} is a reserved SQLite keyword`);
+        }
+    }
+    validateIdentifier(name, context) {
+        if (!name || !name.trim()) {
+            throw new Error(`${context} name cannot be empty`);
+        }
+        if (RESERVED_KEYWORDS.has(name.toUpperCase())) {
+            throw new Error(`${context} name '${name}' is a reserved SQLite keyword`);
+        }
+    }
+    visitInsertQuery(node) {
+        this.validateIdentifier(node['_tableName'], 'InsertQuery');
+        if (node['_columns'].length === 0) {
+            throw new Error('InsertQuery must specify at least one column');
+        }
+        if (node['_columns'].length !== node['_values'].length) {
+            throw new Error('InsertQuery must have the same number of columns and values');
+        }
+        node['_columns'].forEach(col => this.validateIdentifier(col, 'InsertQuery column'));
+        node['_values'].forEach(val => val.accept(this));
+    }
+    visitSelectQuery(node) {
+        if (node['_columns'].length > 0 && node['_fromsAndJoins'].length === 0) {
+            throw new Error('SELECT query with columns must have at least one FROM clause');
+        }
+        const prevCount = this.columnCount;
+        this.columnCount = node['_columns'].length > 0 ? node['_columns'].length : 1;
+        node['_with'].forEach(w => w.accept(this));
+        node['_fromsAndJoins'].forEach(item => this.fromLikeAndJoinAcceptor.accept(this, item));
+        node['_columns'].forEach(c => this.columnLikeAcceptor.accept(this, c));
+        if (node['_where']) {
+            node['_where'].accept(this);
+        }
+        if (node['_groupBy'].length > 0) {
+            this.isGrouped = true;
+            node['_groupBy'].forEach(c => c.accept(this));
+        }
+        if (node['_having'] && !this.isGrouped) {
+            throw new Error('HAVING clause requires GROUP BY');
+        }
+        if (node['_having']) {
+            node['_having'].accept(this);
+        }
+        if (node['_union'].length > 0) {
+            if (node['_columns'].length === 0 && node['_fromsAndJoins'].length === 0) {
+                throw new Error("A query with UNION subqueries must have columns and a FROM clause in the main query");
+            }
+            let columnCounts = [];
+            if (node['_columns'].length > 0) {
+                columnCounts.push(node['_columns'].length); // Include main query
+            }
+            columnCounts = columnCounts.concat(node['_union'].map(u => u['_columns'].length || 1));
+            if (columnCounts.length > 1) {
+                const firstCount = columnCounts[0];
+                if (columnCounts.some(count => count !== firstCount)) {
+                    throw new Error('UNION queries must have the same number of columns');
+                }
+            }
+        }
+        node['_orderBy'].forEach(o => o.accept(this));
+        if (node['_limit'] !== null && node['_limit'] !== undefined && node['_limit'] < 0) {
+            throw new Error('LIMIT must be non-negative');
+        }
+        if (node['_offset'] !== null && node['_offset'] !== undefined && node['_offset'] < 0) {
+            throw new Error('OFFSET must be non-negative');
+        }
+        this.columnCount = prevCount; // Restore parent context if nested
+    }
+    visitTableFrom(node) {
+        this.validateIdentifier(node.tableName, 'TableFrom');
+    }
+    visitSubqueryFrom(node) {
+        const prevCount = this.columnCount;
+        this.columnCount = null; // Reset for subquery
+        node.subquery.accept(this);
+        this.columnCount = prevCount; // Restore parent count
+    }
+    visitJsonEachFrom(node) {
+        node.jsonExpression.accept(this);
+        if (node.jsonPath) {
+            node.jsonPath.accept(this);
+        }
+    }
+    visitColumn(node) {
+        if (node.hasTableName()) {
+            this.validateIdentifier(node.tableName, 'Column');
+        }
+        this.validateIdentifier(node.columnName, 'Column');
+    }
+    visitAlias(node) {
+        if (!node.alias || !node.alias.trim()) {
+            throw new Error('Alias must have a non-empty name');
+        }
+        if (node.referent instanceof Join_1.Join) {
+            this.validateAlias(node.alias, 'Join');
+        }
+        else if (node.referent instanceof Column_1.Column) {
+            this.validateAlias(node.alias, 'Column');
+        }
+        else if (node.referent instanceof From_1.TableFrom) {
+            this.validateAlias(node.alias, 'TableFrom');
+        }
+        else if (node.referent instanceof From_1.SubqueryFrom) {
+            this.validateAlias(node.alias, 'SubqueryFrom');
+        }
+        else if (node.referent instanceof From_1.JsonEachFrom) {
+            this.validateAlias(node.alias, 'JsonEachFrom');
+        }
+        else if (node.referent instanceof Abstractions_1.AliasableExpression) {
+            this.validateAlias(node.alias, 'Expression');
+        }
+        node.referent.accept(this);
+    }
+    visitJoinClause(node) {
+        this.validateIdentifier(node.tableName, 'JoinClause');
+        if (!node.on) {
+            throw new Error('JoinClause must have an ON condition');
+        }
+        node.on.accept(this);
+    }
+    visitOrderBy(node) {
+        node.column.accept(this);
+    }
+    visitWithClause(node) {
+        this.validateIdentifier(node.name, 'WithClause');
+        const prevCount = this.columnCount;
+        this.columnCount = null; // Reset for subquery
+        node.query.accept(this);
+        this.columnCount = prevCount; // Restore parent count
+    }
+    visitBinaryExpression(node) {
+        if (!node.operator) {
+            throw new Error('BinaryExpression must have a valid operator');
+        }
+        if (!node.left) {
+            throw new Error('BinaryExpression must have a valid left operand');
+        }
+        if (!node.right) {
+            throw new Error('BinaryExpression must have a valid right operand');
+        }
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitUnaryExpression(node) {
+        if (!node.operator) {
+            throw new Error('UnaryExpression must have a valid operator');
+        }
+        if (!node.operand) {
+            throw new Error('UnaryExpression must have a valid operand');
+        }
+        node.operand.accept(this);
+    }
+    visitInExpression(node) {
+        if (node.left.length === 0) {
+            throw new Error('IN expression must have at least one left expression');
+        }
+        node.left.forEach(l => l.accept(this));
+        if (node.values instanceof SelectQuery_1.SelectQuery) {
+            node.values.accept(this);
+        }
+        else {
+            if (node.values.length === 0) {
+                throw new Error('IN expression must have at least one value set');
+            }
+            node.values.forEach(set => {
+                if (set.length !== node.left.length) {
+                    throw new Error('Value sets in IN expression must match the number of left expressions');
+                }
+                set.forEach(v => v.accept(this));
+            });
+        }
+    }
+    visitConcat(node) {
+        if (node.expressions.length < 2) {
+            throw new Error('Concat must have at least two expressions');
+        }
+        node.expressions.forEach(e => e.accept(this));
+    }
+    visitCaseExpression(node) {
+        if (node.cases.length === 0) {
+            throw new Error('CaseExpression must have at least one WHEN/THEN pair');
+        }
+        node.cases.forEach(c => {
+            c.when.accept(this);
+            c.then.accept(this);
+        });
+        if (node.else) {
+            node.else.accept(this);
+        }
+    }
+    visitFunctionExpression(node) {
+        const noArgFunctions = ['RANDOM'];
+        if (!noArgFunctions.includes(node.name) && node.args.length === 0) {
+            throw new Error(`Function ${node.name} requires at least one argument`);
+        }
+        node.args.forEach(a => a.accept(this));
+    }
+    visitParamExpression(_node) {
+        // No specific validation needed
+    }
+    visitStringLiteral(node) {
+        if (node.value === null || node.value === undefined) {
+            throw new Error('StringLiteral value cannot be null or undefined');
+        }
+    }
+    visitNumberLiteral(node) {
+        if (isNaN(node.value)) {
+            throw new Error('NumberLiteral value must be a valid number');
+        }
+    }
+    visitNullLiteral(_node) {
+        // No specific validation needed
+    }
+    visitExistsExpression(node) {
+        if (!node.subquery) {
+            throw new Error('ExistsExpression must have a valid subquery');
+        }
+        const prevCount = this.columnCount;
+        this.columnCount = null; // Reset for subquery
+        node.subquery.accept(this);
+        this.columnCount = prevCount; // Restore parent count
+    }
+}
+exports.CommonQueryValidator = CommonQueryValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CommonQueryValidator.js","sourceRoot":"","sources":["../../src/validate/CommonQueryValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import { AliasableExpression } from \"../ast/Abstractions\";\nimport { Alias } from \"../ast/Alias\";\nimport { BinaryExpression } from \"../ast/BinaryExpression\";\nimport { CaseExpression } from \"../ast/CaseExpression\";\nimport { Column } from \"../ast/Column\";\nimport { Concat } from \"../ast/Concat\";\nimport { ExistsExpression } from \"../ast/ExistsExpression\";\nimport { From, JsonEachFrom, SubqueryFrom, TableFrom } from \"../ast/From\";\nimport { FunctionExpression } from \"../ast/FunctionExpression\";\nimport { InExpression } from \"../ast/InExpression\";\nimport { InsertQuery } from \"../ast/InsertQuery\";\nimport { Join } from \"../ast/Join\";\nimport { NullLiteral, NumberLiteral, Param, StringLiteral } from \"../ast/Literals\";\nimport { OrderBy } from \"../ast/OrderBy\";\nimport { SelectQuery } from \"../ast/SelectQuery\";\nimport { UnaryExpression } from \"../ast/UnaryExpression\";\nimport { With } from \"../ast/With\";\nimport { ColumnLikeVisitorAcceptor, FromLikeAndJoinVisitorAcceptor, SqlTreeNodeVisitor } from \"../visitor/SqlTreeNodeVisitor\";\nimport { QueryValidator } from \"./QueryValidator\";\n\nconst RESERVED_KEYWORDS = new Set([\n  'SELECT', 'FROM', 'WHERE', 'JOIN', 'ON', 'GROUP', 'BY', 'HAVING', 'UNION',\n  'ORDER', 'LIMIT', 'OFFSET', 'TABLE', 'INDEX', 'VIEW', 'TRIGGER', 'KEY',\n  'COLUMN', 'CONSTRAINT', 'PRIMARY', 'FOREIGN', 'CHECK', 'DEFAULT', 'NULL',\n  'NOT', 'AND', 'OR', 'LIKE', 'IN', 'IS', 'BETWEEN', 'CASE', 'WHEN', 'THEN',\n  'ELSE', 'END', 'INSERT', 'INTO', 'VALUES', 'EXISTS'\n]);\n\nexport class CommonQueryValidator implements QueryValidator, SqlTreeNodeVisitor<void> {\n  protected fromLikeAndJoinAcceptor = new FromLikeAndJoinVisitorAcceptor<void>();\n  protected columnLikeAcceptor = new ColumnLikeVisitorAcceptor<void>();\n\n  private columnCount: number | null = null;\n  private isGrouped: boolean = false;\n\n  public validate(query: SelectQuery | InsertQuery): void {\n    this.reset();\n    query.accept(this);\n  }\n\n  protected reset(): void {\n    this.columnCount = null;\n    this.isGrouped = false;\n  }\n\n  private validateAlias(alias: string | undefined, context: string): void {\n    if (alias && !alias.trim()) {\n      throw new Error(`Empty alias in ${context}`);\n    }\n    if (alias && RESERVED_KEYWORDS.has(alias.toUpperCase())) {\n      throw new Error(`Alias '${alias}' in ${context} is a reserved SQLite keyword`);\n    }\n  }\n\n  private validateIdentifier(name: string, context: string): void {\n    if (!name || !name.trim()) {\n      throw new Error(`${context} name cannot be empty`);\n    }\n    if (RESERVED_KEYWORDS.has(name.toUpperCase())) {\n      throw new Error(`${context} name '${name}' is a reserved SQLite keyword`);\n    }\n  }\n\n  visitInsertQuery(node: InsertQuery): void {\n    this.validateIdentifier(node['_tableName'], 'InsertQuery');\n    if (node['_columns'].length === 0) {\n      throw new Error('InsertQuery must specify at least one column');\n    }\n    if (node['_columns'].length !== node['_values'].length) {\n      throw new Error('InsertQuery must have the same number of columns and values');\n    }\n    node['_columns'].forEach(col => this.validateIdentifier(col, 'InsertQuery column'));\n    node['_values'].forEach(val => val.accept(this));\n  }\n\n  visitSelectQuery(node: SelectQuery): void {\n    if (node['_columns'].length > 0 && node['_fromsAndJoins'].length === 0) {\n      throw new Error('SELECT query with columns must have at least one FROM clause');\n    }\n\n    const prevCount = this.columnCount;\n    this.columnCount = node['_columns'].length > 0 ? node['_columns'].length : 1;\n\n    node['_with'].forEach(w => w.accept(this));\n    node['_fromsAndJoins'].forEach(item => this.fromLikeAndJoinAcceptor.accept(this, item));\n    node['_columns'].forEach(c => this.columnLikeAcceptor.accept(this, c));\n    if (node['_where']) {\n      node['_where'].accept(this);\n    }\n    if (node['_groupBy'].length > 0) {\n      this.isGrouped = true;\n      node['_groupBy'].forEach(c => c.accept(this));\n    }\n    if (node['_having'] && !this.isGrouped) {\n      throw new Error('HAVING clause requires GROUP BY');\n    }\n    if (node['_having']) {\n      node['_having'].accept(this);\n    }\n    if (node['_union'].length > 0) {\n      if (node['_columns'].length === 0 && node['_fromsAndJoins'].length === 0) {\n        throw new Error(\"A query with UNION subqueries must have columns and a FROM clause in the main query\");\n      }\n      let columnCounts = [];\n      if (node['_columns'].length > 0) {\n        columnCounts.push(node['_columns'].length); // Include main query\n      }\n      columnCounts = columnCounts.concat(node['_union'].map(u => u['_columns'].length || 1));\n      if (columnCounts.length > 1) {\n        const firstCount = columnCounts[0];\n        if (columnCounts.some(count => count !== firstCount)) {\n          throw new Error('UNION queries must have the same number of columns');\n        }\n      }\n    }\n    node['_orderBy'].forEach(o => o.accept(this));\n    if (node['_limit'] !== null && node['_limit'] !== undefined && node['_limit'] < 0) {\n      throw new Error('LIMIT must be non-negative');\n    }\n    if (node['_offset'] !== null && node['_offset'] !== undefined && node['_offset'] < 0) {\n      throw new Error('OFFSET must be non-negative');\n    }\n\n    this.columnCount = prevCount; // Restore parent context if nested\n  }\n\n  visitTableFrom(node: TableFrom): void {\n    this.validateIdentifier(node.tableName, 'TableFrom');\n  }\n\n  visitSubqueryFrom(node: SubqueryFrom): void {\n    const prevCount = this.columnCount;\n    this.columnCount = null; // Reset for subquery\n    node.subquery.accept(this);\n    this.columnCount = prevCount; // Restore parent count\n  }\n\n  visitJsonEachFrom(node: JsonEachFrom): void {\n    node.jsonExpression.accept(this);\n    if (node.jsonPath) {\n      node.jsonPath.accept(this);\n    }\n  }\n\n  visitColumn(node: Column): void {\n    if (node.hasTableName()) {\n      this.validateIdentifier(node.tableName as string, 'Column');\n    }\n    this.validateIdentifier(node.columnName, 'Column');\n  }\n\n  visitAlias(node: Alias<From | AliasableExpression>): void {\n    if (!node.alias || !node.alias.trim()) {\n      throw new Error('Alias must have a non-empty name');\n    }\n    if (node.referent instanceof Join) {\n      this.validateAlias(node.alias, 'Join');\n    } else if (node.referent instanceof Column) {\n      this.validateAlias(node.alias, 'Column');\n    } else if (node.referent instanceof TableFrom) {\n      this.validateAlias(node.alias, 'TableFrom');\n    } else if (node.referent instanceof SubqueryFrom) {\n      this.validateAlias(node.alias, 'SubqueryFrom');\n    } else if (node.referent instanceof JsonEachFrom) {\n      this.validateAlias(node.alias, 'JsonEachFrom');\n    } else if (node.referent instanceof AliasableExpression) {\n      this.validateAlias(node.alias, 'Expression');\n    }\n    node.referent.accept(this);\n  }\n\n  visitJoinClause(node: Join): void {\n    this.validateIdentifier(node.tableName, 'JoinClause');\n    if (!node.on) {\n      throw new Error('JoinClause must have an ON condition');\n    }\n    node.on.accept(this);\n  }\n\n  visitOrderBy(node: OrderBy): void {\n    node.column.accept(this);\n  }\n\n  visitWithClause(node: With): void {\n    this.validateIdentifier(node.name, 'WithClause');\n    const prevCount = this.columnCount;\n    this.columnCount = null; // Reset for subquery\n    node.query.accept(this);\n    this.columnCount = prevCount; // Restore parent count\n  }\n\n  visitBinaryExpression(node: BinaryExpression): void {\n    if (!node.operator) {\n      throw new Error('BinaryExpression must have a valid operator');\n    }\n    if (!node.left) {\n      throw new Error('BinaryExpression must have a valid left operand');\n    }\n    if (!node.right) {\n      throw new Error('BinaryExpression must have a valid right operand');\n    }\n    node.left.accept(this);\n    node.right.accept(this);\n  }\n\n  visitUnaryExpression(node: UnaryExpression): void {\n    if (!node.operator) {\n      throw new Error('UnaryExpression must have a valid operator');\n    }\n    if (!node.operand) {\n      throw new Error('UnaryExpression must have a valid operand');\n    }\n    node.operand.accept(this);\n  }\n\n  visitInExpression(node: InExpression): void {\n    if (node.left.length === 0) {\n      throw new Error('IN expression must have at least one left expression');\n    }\n    node.left.forEach(l => l.accept(this));\n    if (node.values instanceof SelectQuery) {\n      node.values.accept(this);\n    } else {\n      if (node.values.length === 0) {\n        throw new Error('IN expression must have at least one value set');\n      }\n      node.values.forEach(set => {\n        if (set.length !== node.left.length) {\n          throw new Error('Value sets in IN expression must match the number of left expressions');\n        }\n        set.forEach(v => v.accept(this));\n      });\n    }\n  }\n\n  visitConcat(node: Concat): void {\n    if (node.expressions.length < 2) {\n      throw new Error('Concat must have at least two expressions');\n    }\n    node.expressions.forEach(e => e.accept(this));\n  }\n\n  visitCaseExpression(node: CaseExpression): void {\n    if (node.cases.length === 0) {\n      throw new Error('CaseExpression must have at least one WHEN/THEN pair');\n    }\n    node.cases.forEach(c => {\n      c.when.accept(this);\n      c.then.accept(this);\n    });\n    if (node.else) {\n      node.else.accept(this);\n    }\n  }\n\n  visitFunctionExpression(node: FunctionExpression): void {\n    const noArgFunctions = ['RANDOM'];\n    if (!noArgFunctions.includes(node.name) && node.args.length === 0) {\n      throw new Error(`Function ${node.name} requires at least one argument`);\n    }\n    node.args.forEach(a => a.accept(this));\n  }\n\n  visitParamExpression(_node: Param): void {\n    // No specific validation needed\n  }\n\n  visitStringLiteral(node: StringLiteral): void {\n    if (node.value === null || node.value === undefined) {\n      throw new Error('StringLiteral value cannot be null or undefined');\n    }\n  }\n\n  visitNumberLiteral(node: NumberLiteral): void {\n    if (isNaN(node.value)) {\n      throw new Error('NumberLiteral value must be a valid number');\n    }\n  }\n\n  visitNullLiteral(_node: NullLiteral): void {\n    // No specific validation needed\n  }\n\n  visitExistsExpression(node: ExistsExpression): void {\n    if (!node.subquery) {\n      throw new Error('ExistsExpression must have a valid subquery');\n    }\n    const prevCount = this.columnCount;\n    this.columnCount = null; // Reset for subquery\n    node.subquery.accept(this);\n    this.columnCount = prevCount; // Restore parent count\n  }\n}\n"]}

package/dist/validate/QueryValidator.d.ts

@@ -0,0 +1,6 @@
+import { InsertQuery } from "../ast/InsertQuery";
+import { SelectQuery } from "../ast/SelectQuery";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+export interface QueryValidator extends SqlTreeNodeVisitor<void> {
+    validate(node: SelectQuery | InsertQuery): void;
+}

package/dist/validate/QueryValidator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlWYWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmFsaWRhdGUvUXVlcnlWYWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluc2VydFF1ZXJ5IH0gZnJvbSBcIi4uL2FzdC9JbnNlcnRRdWVyeVwiO1xuaW1wb3J0IHsgU2VsZWN0UXVlcnkgfSBmcm9tIFwiLi4vYXN0L1NlbGVjdFF1ZXJ5XCI7XG5pbXBvcnQgeyBTcWxUcmVlTm9kZVZpc2l0b3IgfSBmcm9tIFwiLi4vdmlzaXRvci9TcWxUcmVlTm9kZVZpc2l0b3JcIjtcblxuZXhwb3J0IGludGVyZmFjZSBRdWVyeVZhbGlkYXRvciBleHRlbmRzIFNxbFRyZWVOb2RlVmlzaXRvcjx2b2lkPiB7XG4gIHZhbGlkYXRlKG5vZGU6IFNlbGVjdFF1ZXJ5IHwgSW5zZXJ0UXVlcnkpOiB2b2lkO1xufVxuIl19

package/dist/validate/SQLiteQueryValidator.d.ts

@@ -0,0 +1,27 @@
+import { JsonEachFrom, TableFrom } from "../ast/From";
+import { FunctionExpression } from "../ast/FunctionExpression";
+import { InExpression } from "../ast/InExpression";
+import { InsertQuery } from "../ast/InsertQuery";
+import { Join } from "../ast/Join";
+import { SelectQuery } from "../ast/SelectQuery";
+import { UnaryExpression } from "../ast/UnaryExpression";
+import { With } from "../ast/With";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { CommonQueryValidator } from "./CommonQueryValidator";
+import { QueryValidator } from "./QueryValidator";
+export declare class SQLiteQueryValidator extends CommonQueryValidator implements QueryValidator, SqlTreeNodeVisitor<void> {
+    private supportedFunctions;
+    private supportedUnaryOperators;
+    private isWithRecursive;
+    validate(query: SelectQuery | InsertQuery): void;
+    protected reset(): void;
+    visitInsertQuery(node: InsertQuery): void;
+    visitSelectQuery(node: SelectQuery): void;
+    visitJoinClause(node: Join): void;
+    visitWithClause(node: With): void;
+    visitFunctionExpression(node: FunctionExpression): void;
+    visitTableFrom(node: TableFrom): void;
+    visitJsonEachFrom(node: JsonEachFrom): void;
+    visitUnaryExpression(node: UnaryExpression): void;
+    visitInExpression(node: InExpression): void;
+}

package/dist/validate/SQLiteQueryValidator.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteQueryValidator = void 0;
+const Join_1 = require("../ast/Join");
+const Operator_1 = require("../ast/Operator");
+const CommonQueryValidator_1 = require("./CommonQueryValidator");
+class SQLiteQueryValidator extends CommonQueryValidator_1.CommonQueryValidator {
+    constructor() {
+        super(...arguments);
+        this.supportedFunctions = new Set([
+            // Core scalar functions
+            'ABS', 'CEIL', 'FLOOR', 'ROUND', 'TRUNC', 'RANDOM', 'RANDOMBLOB',
+            'LOWER', 'UPPER', 'LENGTH', 'SUBSTR', 'TRIM', 'LTRIM', 'RTRIM',
+            'REPLACE', 'INSTR', 'QUOTE', 'CHAR', 'UNICODE', 'HEX', 'ZEROBLOB',
+            'COALESCE', 'IFNULL', 'NULLIF', 'TYPEOF', 'TOTAL_CHANGES', 'CHANGES',
+            'LAST_INSERT_ROWID',
+            // Aggregate functions
+            'COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'TOTAL', 'GROUP_CONCAT',
+            // Date and time functions
+            'DATE', 'TIME', 'DATETIME', 'JULIANDAY', 'STRFTIME',
+            // JSON1 functions
+            'json', 'json_array', 'json_object', 'json_extract', 'json_insert',
+            'json_replace', 'json_set', 'json_remove', 'json_type', 'json_valid',
+            'json_quote', 'json_patch', 'json_array_length', 'json_group_array',
+            'json_group_object', 'json_each', 'json_tree'
+        ]);
+        this.supportedUnaryOperators = new Set([
+            Operator_1.Operator.NOT, Operator_1.Operator.PLUS, Operator_1.Operator.MINUS,
+            Operator_1.Operator.IS_NULL, Operator_1.Operator.IS_NOT_NULL,
+        ]);
+        this.isWithRecursive = false;
+    }
+    validate(query) {
+        this.reset();
+        query.accept(this);
+    }
+    reset() {
+        super.reset();
+        this.isWithRecursive = false;
+    }
+    visitInsertQuery(node) {
+        super.visitInsertQuery(node);
+        // SQLite-specific validation (if any) can be added here
+    }
+    visitSelectQuery(node) {
+        super.visitSelectQuery(node);
+        if (node['_limit'] !== null && node['_limit'] !== undefined && !Number.isInteger(node['_limit'])) {
+            throw new Error('SQLite LIMIT must be an integer');
+        }
+        if (node['_offset'] !== null && node['_offset'] !== undefined && !Number.isInteger(node['_offset'])) {
+            throw new Error('SQLite OFFSET must be an integer');
+        }
+    }
+    visitJoinClause(node) {
+        if (node.type === Join_1.JoinType.RIGHT || node.type === Join_1.JoinType.FULL) {
+            throw new Error(`SQLite does not support ${node.type} JOIN`);
+        }
+        super.visitJoinClause(node);
+    }
+    visitWithClause(node) {
+        const prevRecursive = this.isWithRecursive;
+        this.isWithRecursive = false;
+        node.query.accept(this);
+        if (this.isWithRecursive) {
+            throw new Error('Recursive WITH clauses are not supported in this validator');
+        }
+        this.isWithRecursive = prevRecursive;
+        super.visitWithClause(node);
+    }
+    visitFunctionExpression(node) {
+        if (!this.supportedFunctions.has(node.name)) {
+            throw new Error(`Function ${node.name} is not supported in SQLite`);
+        }
+        super.visitFunctionExpression(node);
+    }
+    visitTableFrom(node) {
+        if (this.isWithRecursive) {
+            throw new Error('Recursive reference to WITH clause detected');
+        }
+        super.visitTableFrom(node);
+    }
+    visitJsonEachFrom(node) {
+        super.visitJsonEachFrom(node);
+    }
+    visitUnaryExpression(node) {
+        if (!this.supportedUnaryOperators.has(node.operator)) {
+            throw new Error(`Unary operator ${node.operator} is not supported in SQLite`);
+        }
+        super.visitUnaryExpression(node);
+    }
+    visitInExpression(node) {
+        super.visitInExpression(node);
+    }
+}
+exports.SQLiteQueryValidator = SQLiteQueryValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SQLiteQueryValidator.js","sourceRoot":"","sources":["../../src/validate/SQLiteQueryValidator.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonEachFrom, TableFrom } from \"../ast/From\";\nimport { FunctionExpression } from \"../ast/FunctionExpression\";\nimport { FunctionName } from \"../ast/FunctionName\";\nimport { InExpression } from \"../ast/InExpression\";\nimport { InsertQuery } from \"../ast/InsertQuery\";\nimport { Join, JoinType } from \"../ast/Join\";\nimport { Operator } from \"../ast/Operator\";\nimport { SelectQuery } from \"../ast/SelectQuery\";\nimport { UnaryExpression } from \"../ast/UnaryExpression\";\nimport { With } from \"../ast/With\";\nimport { SqlTreeNodeVisitor } from \"../visitor/SqlTreeNodeVisitor\";\nimport { CommonQueryValidator } from \"./CommonQueryValidator\";\nimport { QueryValidator } from \"./QueryValidator\";\n\nexport class SQLiteQueryValidator\n  extends CommonQueryValidator\n  implements QueryValidator, SqlTreeNodeVisitor<void>\n{\n  private supportedFunctions: Set<FunctionName> = new Set([\n    // Core scalar functions\n    'ABS', 'CEIL', 'FLOOR', 'ROUND', 'TRUNC', 'RANDOM', 'RANDOMBLOB',\n    'LOWER', 'UPPER', 'LENGTH', 'SUBSTR', 'TRIM', 'LTRIM', 'RTRIM',\n    'REPLACE', 'INSTR', 'QUOTE', 'CHAR', 'UNICODE', 'HEX', 'ZEROBLOB',\n    'COALESCE', 'IFNULL', 'NULLIF', 'TYPEOF', 'TOTAL_CHANGES', 'CHANGES',\n    'LAST_INSERT_ROWID',\n    // Aggregate functions\n    'COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'TOTAL', 'GROUP_CONCAT',\n    // Date and time functions\n    'DATE', 'TIME', 'DATETIME', 'JULIANDAY', 'STRFTIME',\n    // JSON1 functions\n    'json', 'json_array', 'json_object', 'json_extract', 'json_insert',\n    'json_replace', 'json_set', 'json_remove', 'json_type', 'json_valid',\n    'json_quote', 'json_patch', 'json_array_length', 'json_group_array',\n    'json_group_object', 'json_each', 'json_tree'\n  ]);\n\n  private supportedUnaryOperators: Set<string> = new Set([\n    Operator.NOT, Operator.PLUS, Operator.MINUS,\n    Operator.IS_NULL, Operator.IS_NOT_NULL,\n  ]);\n\n  private isWithRecursive: boolean = false;\n\n  public validate(query: SelectQuery | InsertQuery): void {\n    this.reset();\n    query.accept(this);\n  }\n\n  protected reset(): void {\n    super.reset();\n    this.isWithRecursive = false;\n  }\n\n  visitInsertQuery(node: InsertQuery): void {\n    super.visitInsertQuery(node);\n    // SQLite-specific validation (if any) can be added here\n  }\n\n  visitSelectQuery(node: SelectQuery): void {\n    super.visitSelectQuery(node);\n    if (node['_limit'] !== null && node['_limit'] !== undefined && !Number.isInteger(node['_limit'])) {\n      throw new Error('SQLite LIMIT must be an integer');\n    }\n    if (node['_offset'] !== null && node['_offset'] !== undefined && !Number.isInteger(node['_offset'])) {\n      throw new Error('SQLite OFFSET must be an integer');\n    }\n  }\n\n  visitJoinClause(node: Join): void {\n    if (node.type === JoinType.RIGHT || node.type === JoinType.FULL) {\n      throw new Error(`SQLite does not support ${node.type} JOIN`);\n    }\n    super.visitJoinClause(node);\n  }\n\n  visitWithClause(node: With): void {\n    const prevRecursive = this.isWithRecursive;\n    this.isWithRecursive = false;\n    node.query.accept(this);\n    if (this.isWithRecursive) {\n      throw new Error('Recursive WITH clauses are not supported in this validator');\n    }\n    this.isWithRecursive = prevRecursive;\n    super.visitWithClause(node);\n  }\n\n  visitFunctionExpression(node: FunctionExpression): void {\n    if (!this.supportedFunctions.has(node.name)) {\n      throw new Error(`Function ${node.name} is not supported in SQLite`);\n    }\n    super.visitFunctionExpression(node);\n  }\n\n  visitTableFrom(node: TableFrom): void {\n    if (this.isWithRecursive) {\n      throw new Error('Recursive reference to WITH clause detected');\n    }\n    super.visitTableFrom(node);\n  }\n\n  visitJsonEachFrom(node: JsonEachFrom): void {\n    super.visitJsonEachFrom(node);\n  }\n\n  visitUnaryExpression(node: UnaryExpression): void {\n    if (!this.supportedUnaryOperators.has(node.operator)) {\n      throw new Error(`Unary operator ${node.operator} is not supported in SQLite`);\n    }\n    super.visitUnaryExpression(node);\n  }\n\n  visitInExpression(node: InExpression): void {\n    super.visitInExpression(node);\n  }\n}\n"]}