@shaxpir/squilt 1.0.0

package/dist/builder/Shorthand.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VAL = VAL;
+exports.EQ = EQ;
+exports.NOT_EQ = NOT_EQ;
+exports.NOT = NOT;
+exports.GT = GT;
+exports.LT = LT;
+exports.GTE = GTE;
+exports.LTE = LTE;
+exports.LIKE = LIKE;
+exports.IS_NULL = IS_NULL;
+exports.IS_NOT_NULL = IS_NOT_NULL;
+exports.PLUS = PLUS;
+exports.MINUS = MINUS;
+exports.MULTIPLY = MULTIPLY;
+exports.DIVIDE = DIVIDE;
+exports.AND = AND;
+exports.OR = OR;
+exports.EXISTS = EXISTS;
+exports.COLUMN = COLUMN;
+exports.SELECT = SELECT;
+exports.SELECT_DISTINCT = SELECT_DISTINCT;
+exports.FROM = FROM;
+exports.UNION = UNION;
+exports.JOIN = JOIN;
+exports.LEFT_JOIN = LEFT_JOIN;
+exports.CROSS_JOIN = CROSS_JOIN;
+exports.ABS = ABS;
+exports.COUNT = COUNT;
+exports.SUM = SUM;
+exports.FN = FN;
+exports.FN_DISTINCT = FN_DISTINCT;
+exports.CONCAT = CONCAT;
+exports.PARAM = PARAM;
+exports.INSERT = INSERT;
+exports.INSERT_OR_REPLACE = INSERT_OR_REPLACE;
+exports.IN = IN;
+exports.NOT_IN = NOT_IN;
+exports.GROUP_BY = GROUP_BY;
+exports.HAVING = HAVING;
+exports.ORDER_BY = ORDER_BY;
+exports.CASE = CASE;
+exports.WITH = WITH;
+const Abstractions_1 = require("../ast/Abstractions");
+const Alias_1 = require("../ast/Alias");
+const BinaryExpression_1 = require("../ast/BinaryExpression");
+const CaseExpression_1 = require("../ast/CaseExpression");
+const Column_1 = require("../ast/Column");
+const Concat_1 = require("../ast/Concat");
+const ExistsExpression_1 = require("../ast/ExistsExpression");
+const From_1 = require("../ast/From");
+const FunctionExpression_1 = require("../ast/FunctionExpression");
+const InExpression_1 = require("../ast/InExpression");
+const Join_1 = require("../ast/Join");
+const Literals_1 = require("../ast/Literals");
+const Operator_1 = require("../ast/Operator");
+const OrderBy_1 = require("../ast/OrderBy");
+const SelectQuery_1 = require("../ast/SelectQuery");
+const UnaryExpression_1 = require("../ast/UnaryExpression");
+const With_1 = require("../ast/With");
+const QueryBuilder_1 = require("./QueryBuilder");
+function VAL(val) {
+    return LAZY(val);
+}
+// --- Operators ---
+function EQ(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.EQUALS, LAZY(right));
+}
+function NOT_EQ(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.NOT_EQUALS, LAZY(right));
+}
+function NOT(expr) {
+    return new UnaryExpression_1.UnaryExpression(Operator_1.Operator.NOT, LAZY(expr));
+}
+function GT(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.GREATER_THAN, LAZY(right));
+}
+function LT(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.LESS_THAN, LAZY(right));
+}
+function GTE(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.GREATER_THAN_OR_EQUAL, LAZY(right));
+}
+function LTE(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.LESS_THAN_OR_EQUAL, LAZY(right));
+}
+function LIKE(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.LIKE, LAZY(right));
+}
+function IS_NULL(expr) {
+    return new UnaryExpression_1.UnaryExpression(Operator_1.Operator.IS_NULL, LAZY(expr));
+}
+function IS_NOT_NULL(expr) {
+    return new UnaryExpression_1.UnaryExpression(Operator_1.Operator.IS_NOT_NULL, LAZY(expr));
+}
+function PLUS(left, right) {
+    if (right === undefined) {
+        return new UnaryExpression_1.UnaryExpression(Operator_1.Operator.PLUS, LAZY(left));
+    }
+    else {
+        return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.PLUS, LAZY(right));
+    }
+}
+function MINUS(left, right) {
+    if (right === undefined) {
+        return new UnaryExpression_1.UnaryExpression(Operator_1.Operator.MINUS, LAZY(left));
+    }
+    else {
+        return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.MINUS, LAZY(right));
+    }
+}
+function MULTIPLY(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.MULTIPLY, LAZY(right));
+}
+function DIVIDE(left, right) {
+    return new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.DIVIDE, LAZY(right));
+}
+function AND(...args) {
+    if (args.length == 1) {
+        return LAZY(args[0]);
+    }
+    if (args.length < 1) {
+        throw new Error('AND requires at least one arguments');
+    }
+    return args.reduce((left, right) => new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.AND, LAZY(right)));
+}
+function OR(...args) {
+    if (args.length == 1) {
+        return LAZY(args[0]);
+    }
+    else if (args.length < 1) {
+        throw new Error('OR requires at least one arguments');
+    }
+    return args.reduce((left, right) => new BinaryExpression_1.BinaryExpression(LAZY(left), Operator_1.Operator.OR, LAZY(right)));
+}
+// --- EXISTS ---
+function EXISTS(subquery) {
+    return new ExistsExpression_1.ExistsExpression(subquery);
+}
+// --- Columns ---
+function COLUMN(arg1, arg2) {
+    return new Column_1.Column(arg1, arg2);
+}
+// --- Select Queries ---
+function SELECT(...args) {
+    return addClausesToSelect(QueryBuilder_1.QueryBuilder.select(), args);
+}
+function SELECT_DISTINCT(...args) {
+    return addClausesToSelect(QueryBuilder_1.QueryBuilder.select().distinct(), args);
+}
+function addClausesToSelect(query, args) {
+    for (let arg of args) {
+        if (arg instanceof Join_1.Join) {
+            query.join(arg);
+        }
+        else if (arg instanceof From_1.From) {
+            query.from(arg);
+        }
+        else if (arg instanceof Column_1.Column) {
+            query.column(arg);
+        }
+        else if (arg instanceof Alias_1.Alias) {
+            const referent = arg.referent;
+            if (referent instanceof From_1.From) {
+                query.from(arg);
+            }
+            else {
+                query.column(arg);
+            }
+        }
+        else if (arg && typeof arg === 'object' && 'referent' in arg && 'alias' in arg) {
+            // Handle ColumnLike object form
+            query.column(new Alias_1.Alias(arg.referent, arg.alias));
+        }
+        else {
+            query.column(LAZY(arg));
+        }
+    }
+    return query;
+}
+function FROM(arg1, arg2) {
+    // Two-argument form: FROM(database, table)
+    if (typeof arg1 === 'string' && typeof arg2 === 'string') {
+        return new From_1.TableFrom(`${arg1}.${arg2}`);
+    }
+    // Single-argument form (existing behavior)
+    if (typeof arg1 === 'string') {
+        return new From_1.TableFrom(arg1);
+    }
+    else if (arg1 instanceof Alias_1.Alias) {
+        return arg1;
+    }
+    else if (arg1 instanceof SelectQuery_1.SelectQuery) {
+        return new From_1.SubqueryFrom(arg1);
+    }
+    else if (arg1 instanceof From_1.TableFrom ||
+        arg1 instanceof From_1.SubqueryFrom ||
+        arg1 instanceof From_1.JsonEachFrom) {
+        return arg1;
+    }
+    else {
+        throw new Error('unexpected argument type for FROM: ' + JSON.stringify(arg1));
+    }
+}
+function UNION(...queries) {
+    const query = QueryBuilder_1.QueryBuilder.select();
+    queries.forEach(q => query.union(q));
+    return query;
+}
+// --- Joins ---
+function JOIN(tableName, alias, on) {
+    return new Join_1.Join(Join_1.JoinType.INNER, tableName, alias, LAZY(on));
+}
+function LEFT_JOIN(tableName, alias, on) {
+    return new Join_1.Join(Join_1.JoinType.LEFT, tableName, alias, LAZY(on));
+}
+function CROSS_JOIN(tableName, alias) {
+    return new Join_1.Join(Join_1.JoinType.CROSS, tableName, alias, new Literals_1.StringLiteral('TRUE'));
+}
+// --- SQL Functions ---
+function ABS(column) {
+    return new FunctionExpression_1.FunctionExpression('ABS', [column]);
+}
+function COUNT(column) {
+    return new FunctionExpression_1.FunctionExpression('COUNT', [column]);
+}
+function SUM(column) {
+    return new FunctionExpression_1.FunctionExpression('SUM', [column]);
+}
+function FN(name, ...args) {
+    return new FunctionExpression_1.FunctionExpression(name, args.map(LAZY));
+}
+function FN_DISTINCT(name, ...args) {
+    return new FunctionExpression_1.FunctionExpression(name, args.map(LAZY), true);
+}
+// --- Concatenation ---
+function CONCAT(...args) {
+    return new Concat_1.Concat(...args.map(LAZY));
+}
+// --- Parameters ---
+function PARAM(name) {
+    return new Literals_1.Param(name);
+}
+// --- Insert Queries ---
+function INSERT(tableName, columns, values) {
+    return QueryBuilder_1.QueryBuilder.insertInto(tableName)
+        .columns(...columns)
+        .values(...values.map(LAZY));
+}
+function INSERT_OR_REPLACE(arg1, arg2, arg3, arg4) {
+    // Four-argument form: INSERT_OR_REPLACE(database, table, columns, values)
+    if (typeof arg2 === 'string' && Array.isArray(arg3) && Array.isArray(arg4)) {
+        const qualifiedTableName = `${arg1}.${arg2}`;
+        return QueryBuilder_1.QueryBuilder.insertInto(qualifiedTableName)
+            .orReplace()
+            .columns(...arg3)
+            .values(...arg4.map(LAZY));
+    }
+    // Three-argument form: INSERT_OR_REPLACE(tableName, columns, values)
+    if (Array.isArray(arg2) && Array.isArray(arg3)) {
+        return QueryBuilder_1.QueryBuilder.insertInto(arg1)
+            .orReplace()
+            .columns(...arg2)
+            .values(...arg3.map(LAZY));
+    }
+    throw new Error('Invalid arguments for INSERT_OR_REPLACE');
+}
+// Implementation for IN
+function IN(left, ...args) {
+    const not = false;
+    const resolvedLeft = Array.isArray(left) ? left.map(LAZY) : LAZY(left);
+    let resolvedValues;
+    if (Array.isArray(left)) {
+        // Multi-column case
+        if (args.length === 1 && args[0] instanceof SelectQuery_1.SelectQuery) {
+            resolvedValues = args[0];
+        }
+        else {
+            const valuesArg = args[0];
+            resolvedValues = valuesArg.map(set => set.map(LAZY));
+        }
+    }
+    else {
+        // Single-column case
+        if (args.length === 1 && args[0] instanceof SelectQuery_1.SelectQuery) {
+            resolvedValues = args[0];
+        }
+        else {
+            resolvedValues = args.map(LAZY).map(v => [v]);
+        }
+    }
+    return new InExpression_1.InExpression(resolvedLeft, resolvedValues, not);
+}
+// Implementation for NOT_IN
+function NOT_IN(left, ...args) {
+    const not = true;
+    const resolvedLeft = Array.isArray(left) ? left.map(LAZY) : LAZY(left);
+    let resolvedValues;
+    if (Array.isArray(left)) {
+        // Multi-column case
+        if (args.length === 1 && args[0] instanceof SelectQuery_1.SelectQuery) {
+            resolvedValues = args[0];
+        }
+        else {
+            const valuesArg = args[0];
+            resolvedValues = valuesArg.map(set => set.map(LAZY));
+        }
+    }
+    else {
+        // Single-column case
+        if (args.length === 1 && args[0] instanceof SelectQuery_1.SelectQuery) {
+            resolvedValues = args[0];
+        }
+        else {
+            resolvedValues = args.map(LAZY).map(v => [v]);
+        }
+    }
+    return new InExpression_1.InExpression(resolvedLeft, resolvedValues, not);
+}
+function GROUP_BY(...columns) {
+    return columns.map(col => (typeof col === 'string' ? COLUMN(col) : col));
+}
+function HAVING(expr) {
+    return LAZY(expr);
+}
+function ORDER_BY(column, direction = OrderBy_1.OrderByDirection.ASC) {
+    return new OrderBy_1.OrderBy(typeof column === 'string' ? COLUMN(column) : column, direction);
+}
+// --- CASE Expressions ---
+function CASE(lazyCases) {
+    let elseExpr = undefined;
+    const caseItems = [];
+    for (const c of lazyCases) {
+        if (c.WHEN !== undefined && c.THEN !== undefined) {
+            if (elseExpr) {
+                throw new Error('ELSE must be the last clause in a CASE expression');
+            }
+            caseItems.push({ when: LAZY(c.WHEN), then: LAZY(c.THEN) });
+        }
+        else if (c.ELSE !== undefined) {
+            if (elseExpr) {
+                throw new Error('CASE expression can only have one ELSE clause');
+            }
+            elseExpr = LAZY(c.ELSE);
+        }
+    }
+    return new CaseExpression_1.CaseExpression(caseItems, elseExpr);
+}
+// --- Subqueries and WITH Clauses ---
+function WITH(name, query) {
+    return new With_1.With(name, query);
+}
+// --- Literal Conversion ---
+function LAZY(value) {
+    if (value === null) {
+        return Literals_1.NullLiteral.INSTANCE;
+    }
+    else if (typeof value === 'boolean') {
+        return new Literals_1.NumberLiteral(value ? 1 : 0);
+    }
+    else if (typeof value === 'string') {
+        return new Literals_1.StringLiteral(value);
+    }
+    else if (typeof value === 'number') {
+        return new Literals_1.NumberLiteral(value);
+    }
+    else if (value instanceof Abstractions_1.AliasableExpression) {
+        return value;
+    }
+    else {
+        throw new Error(`Unsupported value type: ${typeof value}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Shorthand.js","sourceRoot":"","sources":["../../src/builder/Shorthand.ts"],"names":[],"mappings":"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","sourcesContent":["import { AliasableExpression, Expression } from \"../ast/Abstractions\";\nimport { Alias } from \"../ast/Alias\";\nimport { BinaryExpression } from \"../ast/BinaryExpression\";\nimport { CaseExpression, CaseItem } from \"../ast/CaseExpression\";\nimport { Column, ColumnLike } from \"../ast/Column\";\nimport { Concat } from \"../ast/Concat\";\nimport { ExistsExpression } from \"../ast/ExistsExpression\";\nimport { From, FromLike, JsonEachFrom, SubqueryFrom, 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 { NullLiteral, NumberLiteral, Param, StringLiteral } from \"../ast/Literals\";\nimport { Operator } from \"../ast/Operator\";\nimport { OrderBy, OrderByDirection } from \"../ast/OrderBy\";\nimport { SelectQuery } from \"../ast/SelectQuery\";\nimport { UnaryExpression } from \"../ast/UnaryExpression\";\nimport { With } from \"../ast/With\";\nimport { QueryBuilder } from \"./QueryBuilder\";\n\ntype PrimitiveValue = string | number | boolean | null;\n\ntype LazyExpression = Expression | PrimitiveValue;\n\ntype LazyCaseItem = { WHEN?: LazyExpression; THEN?: LazyExpression; ELSE?: LazyExpression };\n\ntype LazyFrom = string | From | Alias<From> | SelectQuery;\n\ntype LazyColumn = ColumnLike | PrimitiveValue;\n\nexport function VAL(val: PrimitiveValue): AliasableExpression {\n  return LAZY(val);\n}\n\n// --- Operators ---\n\nexport function EQ(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.EQUALS, LAZY(right));\n}\n\nexport function NOT_EQ(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.NOT_EQUALS, LAZY(right));\n}\n\nexport function NOT(expr: LazyExpression): UnaryExpression {\n  return new UnaryExpression(Operator.NOT, LAZY(expr));\n}\n\nexport function GT(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.GREATER_THAN, LAZY(right));\n}\n\nexport function LT(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.LESS_THAN, LAZY(right));\n}\n\nexport function GTE(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.GREATER_THAN_OR_EQUAL, LAZY(right));\n}\n\nexport function LTE(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.LESS_THAN_OR_EQUAL, LAZY(right));\n}\n\nexport function LIKE(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.LIKE, LAZY(right));\n}\n\nexport function IS_NULL(expr: LazyExpression): UnaryExpression {\n  return new UnaryExpression(Operator.IS_NULL, LAZY(expr));\n}\n\nexport function IS_NOT_NULL(expr: LazyExpression): UnaryExpression {\n  return new UnaryExpression(Operator.IS_NOT_NULL, LAZY(expr));\n}\n\nexport function PLUS(left: LazyExpression, right?: LazyExpression): AliasableExpression {\n  if (right === undefined) {\n    return new UnaryExpression(Operator.PLUS, LAZY(left));\n  } else {\n    return new BinaryExpression(LAZY(left), Operator.PLUS, LAZY(right));\n  }\n}\n\nexport function MINUS(left: LazyExpression, right?: LazyExpression): AliasableExpression {\n  if (right === undefined) {\n    return new UnaryExpression(Operator.MINUS, LAZY(left));\n  } else {\n    return new BinaryExpression(LAZY(left), Operator.MINUS, LAZY(right));\n  }\n}\n\nexport function MULTIPLY(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.MULTIPLY, LAZY(right));\n}\n\nexport function DIVIDE(left: LazyExpression, right: LazyExpression): BinaryExpression {\n  return new BinaryExpression(LAZY(left), Operator.DIVIDE, LAZY(right));\n}\n\nexport function AND(...args: LazyExpression[]): AliasableExpression {\n  if (args.length == 1) {\n    return LAZY(args[0])\n  } if (args.length < 1) {\n    throw new Error('AND requires at least one arguments');\n  }\n  return args.reduce((left, right) => new BinaryExpression(LAZY(left), Operator.AND, LAZY(right))) as AliasableExpression;\n}\n\nexport function OR(...args: LazyExpression[]): AliasableExpression {\n  if (args.length == 1) {\n    return LAZY(args[0])\n  } else if (args.length < 1) {\n    throw new Error('OR requires at least one arguments');\n  }\n  return args.reduce((left, right) => new BinaryExpression(LAZY(left), Operator.OR, LAZY(right))) as AliasableExpression;\n}\n\n// --- EXISTS ---\n\nexport function EXISTS(subquery: SelectQuery): ExistsExpression {\n  return new ExistsExpression(subquery);\n}\n\n// --- Columns ---\n\nexport function COLUMN(arg1: string, arg2?: string): Column {\n  return new Column(arg1, arg2);\n}\n\n// --- Select Queries ---\n\nexport function SELECT(...args: (FromLike | Join | LazyColumn)[]): SelectQuery {\n  return addClausesToSelect(QueryBuilder.select(), args);\n}\n\nexport function SELECT_DISTINCT(...args: (FromLike | Join | LazyColumn)[]): SelectQuery {\n  return addClausesToSelect(QueryBuilder.select().distinct(), args);\n}\n\nfunction addClausesToSelect(query: SelectQuery, args: (FromLike | Join | LazyColumn)[]): SelectQuery {\n  for (let arg of args) {\n    if (arg instanceof Join) {\n      query.join(arg);\n    } else if (arg instanceof From) {\n      query.from(arg);\n    } else if (arg instanceof Column) {\n      query.column(arg);\n    } else if (arg instanceof Alias) {\n      const referent = arg.referent as any;\n      if (referent instanceof From) {\n        query.from(arg);\n      } else {\n        query.column(arg);\n      }\n    } else if (arg && typeof arg === 'object' && 'referent' in (arg as any) && 'alias' in (arg as any)) {\n      // Handle ColumnLike object form\n      query.column(new Alias((arg as any).referent, (arg as any).alias));\n    } else {\n      query.column(LAZY(arg as LazyExpression));\n    }\n  }\n  return query;\n}\n\nexport function FROM(arg1: LazyFrom, arg2?: string): From|Alias<From> {\n  // Two-argument form: FROM(database, table)\n  if (typeof arg1 === 'string' && typeof arg2 === 'string') {\n    return new TableFrom(`${arg1}.${arg2}`);\n  }\n\n  // Single-argument form (existing behavior)\n  if (typeof arg1 === 'string') {\n    return new TableFrom(arg1);\n  } else if (arg1 instanceof Alias) {\n    return arg1;\n  } else if (arg1 instanceof SelectQuery) {\n    return new SubqueryFrom(arg1);\n  } else if (\n    arg1 instanceof TableFrom ||\n    arg1 instanceof SubqueryFrom ||\n    arg1 instanceof JsonEachFrom\n  ) {\n    return arg1;\n  } else {\n    throw new Error('unexpected argument type for FROM: ' + JSON.stringify(arg1));\n  }\n}\n\nexport function UNION(...queries: SelectQuery[]): SelectQuery {\n  const query = QueryBuilder.select();\n  queries.forEach(q => query.union(q));\n  return query;\n}\n\n// --- Joins ---\n\nexport function JOIN(tableName: string, alias: string, on: LazyExpression): Join {\n  return new Join(JoinType.INNER, tableName, alias, LAZY(on));\n}\n\nexport function LEFT_JOIN(tableName: string, alias: string, on: LazyExpression): Join {\n  return new Join(JoinType.LEFT, tableName, alias, LAZY(on));\n}\n\nexport function CROSS_JOIN(tableName: string, alias: string): Join {\n  return new Join(JoinType.CROSS, tableName, alias, new StringLiteral('TRUE'));\n}\n\n// --- SQL Functions ---\n\nexport function ABS(column:Expression): FunctionExpression {\n  return new FunctionExpression('ABS', [ column ]);\n}\n\nexport function COUNT(column:Column|FunctionExpression|AliasableExpression): FunctionExpression {\n  return new FunctionExpression('COUNT', [ column ]);\n}\n\nexport function SUM(column:Column|FunctionExpression|AliasableExpression): FunctionExpression {\n  return new FunctionExpression('SUM', [ column ]);\n}\n\nexport function FN(name: FunctionName, ...args: LazyExpression[]): FunctionExpression {\n  return new FunctionExpression(name, args.map(LAZY));\n}\n\nexport function FN_DISTINCT(name: FunctionName, ...args: LazyExpression[]): FunctionExpression {\n  return new FunctionExpression(name, args.map(LAZY), true);\n}\n\n// --- Concatenation ---\n\nexport function CONCAT(...args: LazyExpression[]): Concat {\n  return new Concat(...args.map(LAZY));\n}\n\n// --- Parameters ---\n\nexport function PARAM(name?: string): Param {\n  return new Param(name);\n}\n\n// --- Insert Queries ---\n\nexport function INSERT(tableName: string, columns: string[], values: LazyExpression[]): InsertQuery {\n  return QueryBuilder.insertInto(tableName)\n    .columns(...columns)\n    .values(...values.map(LAZY));\n}\n\nexport function INSERT_OR_REPLACE(database: string, table: string, columns: string[], values: LazyExpression[]): InsertQuery;\nexport function INSERT_OR_REPLACE(tableName: string, columns: string[], values: LazyExpression[]): InsertQuery;\nexport function INSERT_OR_REPLACE(arg1: string, arg2: string | string[], arg3?: string[] | LazyExpression[], arg4?: LazyExpression[]): InsertQuery {\n  // Four-argument form: INSERT_OR_REPLACE(database, table, columns, values)\n  if (typeof arg2 === 'string' && Array.isArray(arg3) && Array.isArray(arg4)) {\n    const qualifiedTableName = `${arg1}.${arg2}`;\n    return QueryBuilder.insertInto(qualifiedTableName)\n      .orReplace()\n      .columns(...(arg3 as string[]))\n      .values(...arg4.map(LAZY));\n  }\n\n  // Three-argument form: INSERT_OR_REPLACE(tableName, columns, values)\n  if (Array.isArray(arg2) && Array.isArray(arg3)) {\n    return QueryBuilder.insertInto(arg1)\n      .orReplace()\n      .columns(...arg2)\n      .values(...(arg3 as LazyExpression[]).map(LAZY));\n  }\n\n  throw new Error('Invalid arguments for INSERT_OR_REPLACE');\n}\n\n// --- Other Clauses ---\n\n// Overloads for IN\nexport function IN(left: LazyExpression, ...values: LazyExpression[]): InExpression;\nexport function IN(left: LazyExpression, values: SelectQuery): InExpression;\nexport function IN(left: LazyExpression[], values: LazyExpression[][]): InExpression;\nexport function IN(left: LazyExpression[], values: SelectQuery): InExpression;\n\n// Implementation for IN\nexport function IN(left: LazyExpression | LazyExpression[], ...args: any[]): InExpression {\n  const not = false;\n  const resolvedLeft = Array.isArray(left) ? left.map(LAZY) : LAZY(left);\n  let resolvedValues: Expression[][] | SelectQuery;\n  if (Array.isArray(left)) {\n    // Multi-column case\n    if (args.length === 1 && args[0] instanceof SelectQuery) {\n      resolvedValues = args[0];\n    } else {\n      const valuesArg = args[0] as LazyExpression[][];\n      resolvedValues = valuesArg.map(set => set.map(LAZY));\n    }\n  } else {\n    // Single-column case\n    if (args.length === 1 && args[0] instanceof SelectQuery) {\n      resolvedValues = args[0];\n    } else {\n      resolvedValues = args.map(LAZY).map(v => [v]);\n    }\n  }\n  return new InExpression(resolvedLeft, resolvedValues, not);\n}\n\n// Overloads for NOT_IN\nexport function NOT_IN(left: LazyExpression, ...values: LazyExpression[]): InExpression;\nexport function NOT_IN(left: LazyExpression, values: SelectQuery): InExpression;\nexport function NOT_IN(left: LazyExpression[], values: LazyExpression[][]): InExpression;\nexport function NOT_IN(left: LazyExpression[], values: SelectQuery): InExpression;\n\n// Implementation for NOT_IN\nexport function NOT_IN(left: LazyExpression | LazyExpression[], ...args: any[]): InExpression {\n  const not = true;\n  const resolvedLeft = Array.isArray(left) ? left.map(LAZY) : LAZY(left);\n  let resolvedValues: Expression[][] | SelectQuery;\n  if (Array.isArray(left)) {\n    // Multi-column case\n    if (args.length === 1 && args[0] instanceof SelectQuery) {\n      resolvedValues = args[0];\n    } else {\n      const valuesArg = args[0] as LazyExpression[][];\n      resolvedValues = valuesArg.map(set => set.map(LAZY));\n    }\n  } else {\n    // Single-column case\n    if (args.length === 1 && args[0] instanceof SelectQuery) {\n      resolvedValues = args[0];\n    } else {\n      resolvedValues = args.map(LAZY).map(v => [v]);\n    }\n  }\n  return new InExpression(resolvedLeft, resolvedValues, not);\n}\n\nexport function GROUP_BY(...columns: (Column | string)[]): Column[] {\n  return columns.map(col => (typeof col === 'string' ? COLUMN(col) : col));\n}\n\nexport function HAVING(expr: LazyExpression): Expression {\n  return LAZY(expr);\n}\n\nexport function ORDER_BY(column: Column | string, direction: OrderByDirection = OrderByDirection.ASC): OrderBy {\n  return new OrderBy(typeof column === 'string' ? COLUMN(column) : column, direction);\n}\n\n// --- CASE Expressions ---\n\nexport function CASE(lazyCases: LazyCaseItem[]): CaseExpression {\n  let elseExpr: Expression | undefined = undefined;\n  const caseItems: CaseItem[] = [];\n  for (const c of lazyCases) {\n    if (c.WHEN !== undefined && c.THEN !== undefined) {\n      if (elseExpr) {\n        throw new Error('ELSE must be the last clause in a CASE expression');\n      }\n      caseItems.push({ when: LAZY(c.WHEN), then: LAZY(c.THEN) });\n    } else if (c.ELSE !== undefined) {\n      if (elseExpr) {\n        throw new Error('CASE expression can only have one ELSE clause');\n      }\n      elseExpr = LAZY(c.ELSE);\n    }\n  }\n  return new CaseExpression(caseItems, elseExpr);\n}\n\n// --- Subqueries and WITH Clauses ---\n\nexport function WITH(name: string, query: SelectQuery): With {\n  return new With(name, query);\n}\n\n// --- Literal Conversion ---\n\nfunction LAZY(value: LazyExpression): AliasableExpression {\n  if (value === null) {\n    return NullLiteral.INSTANCE;\n  } else if (typeof value === 'boolean') {\n    return new NumberLiteral(value ? 1 : 0);\n  } else if (typeof value === 'string') {\n    return new StringLiteral(value);\n  } else if (typeof value === 'number') {\n    return new NumberLiteral(value);\n  } else if (value instanceof AliasableExpression) {\n    return value;\n  } else {\n    throw new Error(`Unsupported value type: ${typeof value}`);\n  }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { SqlTreeNode, Aliasable, Expression, AliasableExpression } from './ast/Abstractions';
+export { Alias } from './ast/Alias';
+export { BinaryExpression } from './ast/BinaryExpression';
+export { CaseExpression, CaseItem } from './ast/CaseExpression';
+export { Column, ColumnLike } from './ast/Column';
+export { Concat } from './ast/Concat';
+export { ExistsExpression } from './ast/ExistsExpression';
+export { From, FromLike, TableFrom, SubqueryFrom, JsonEachFrom } from './ast/From';
+export { FunctionExpression } from './ast/FunctionExpression';
+export { FunctionName } from './ast/FunctionName';
+export { InExpression } from './ast/InExpression';
+export { InsertQuery } from './ast/InsertQuery';
+export { Join, JoinType } from './ast/Join';
+export { LiteralExpression, NumberLiteral, StringLiteral, NullLiteral, Param } from './ast/Literals';
+export { Operator } from './ast/Operator';
+export { OrderBy, OrderByDirection } from './ast/OrderBy';
+export { SelectQuery } from './ast/SelectQuery';
+export { UnaryExpression } from './ast/UnaryExpression';
+export { With } from './ast/With';
+export { QueryBuilder } from './builder/QueryBuilder';
+export { VAL, EQ, NOT_EQ, NOT, GT, LT, GTE, LTE, LIKE, IS_NULL, IS_NOT_NULL, PLUS, MINUS, MULTIPLY, DIVIDE, AND, OR, EXISTS, COLUMN, SELECT, SELECT_DISTINCT, FROM, UNION, JOIN, LEFT_JOIN, CROSS_JOIN, ABS, COUNT, SUM, FN, FN_DISTINCT, CONCAT, PARAM, INSERT, INSERT_OR_REPLACE, IN, NOT_IN, GROUP_BY, HAVING, ORDER_BY, CASE, WITH } from './builder/Shorthand';
+export { QueryRenderer, quoteIdentifier, shouldQuoteIdentifier } from './renderer/QueryRenderer';
+export { CompactQueryRenderer } from './renderer/CompactQueryRenderer';
+export { IndentedQueryRenderer } from './renderer/IndentedQueryRenderer';
+export { QueryValidator } from './validate/QueryValidator';
+export { CommonQueryValidator } from './validate/CommonQueryValidator';
+export { SQLiteQueryValidator } from './validate/SQLiteQueryValidator';
+export { SqlTreeNodeVisitor, FromLikeAndJoinVisitorAcceptor, ColumnLikeVisitorAcceptor } from './visitor/SqlTreeNodeVisitor';
+export { SqlTreeNodeTransformer } from './visitor/SqlTreeNodeTransformer';
+export { QueryIdentityTransformer } from './visitor/QueryIdentityTransformer';
+export { QueryParamRewriteTransformer, ParamReplacements } from './visitor/QueryParamRewriteTransformer';
+export { ParamCollectingVisitor } from './visitor/ParamCollector';

package/dist/index.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FROM = exports.SELECT_DISTINCT = exports.SELECT = exports.COLUMN = exports.EXISTS = exports.OR = exports.AND = exports.DIVIDE = exports.MULTIPLY = exports.MINUS = exports.PLUS = exports.IS_NOT_NULL = exports.IS_NULL = exports.LIKE = exports.LTE = exports.GTE = exports.LT = exports.GT = exports.NOT = exports.NOT_EQ = exports.EQ = exports.VAL = exports.QueryBuilder = exports.With = exports.UnaryExpression = exports.SelectQuery = exports.OrderByDirection = exports.OrderBy = exports.Operator = exports.Param = exports.NullLiteral = exports.StringLiteral = exports.NumberLiteral = exports.LiteralExpression = exports.JoinType = exports.Join = exports.InsertQuery = exports.InExpression = exports.FunctionExpression = exports.JsonEachFrom = exports.SubqueryFrom = exports.TableFrom = exports.From = exports.ExistsExpression = exports.Concat = exports.Column = exports.CaseExpression = exports.BinaryExpression = exports.Alias = exports.AliasableExpression = void 0;
+exports.ParamCollectingVisitor = exports.QueryParamRewriteTransformer = exports.QueryIdentityTransformer = exports.ColumnLikeVisitorAcceptor = exports.FromLikeAndJoinVisitorAcceptor = exports.SQLiteQueryValidator = exports.CommonQueryValidator = exports.IndentedQueryRenderer = exports.CompactQueryRenderer = exports.shouldQuoteIdentifier = exports.quoteIdentifier = exports.WITH = exports.CASE = exports.ORDER_BY = exports.HAVING = exports.GROUP_BY = exports.NOT_IN = exports.IN = exports.INSERT_OR_REPLACE = exports.INSERT = exports.PARAM = exports.CONCAT = exports.FN_DISTINCT = exports.FN = exports.SUM = exports.COUNT = exports.ABS = exports.CROSS_JOIN = exports.LEFT_JOIN = exports.JOIN = exports.UNION = void 0;
+// AST nodes
+var Abstractions_1 = require("./ast/Abstractions");
+Object.defineProperty(exports, "AliasableExpression", { enumerable: true, get: function () { return Abstractions_1.AliasableExpression; } });
+var Alias_1 = require("./ast/Alias");
+Object.defineProperty(exports, "Alias", { enumerable: true, get: function () { return Alias_1.Alias; } });
+var BinaryExpression_1 = require("./ast/BinaryExpression");
+Object.defineProperty(exports, "BinaryExpression", { enumerable: true, get: function () { return BinaryExpression_1.BinaryExpression; } });
+var CaseExpression_1 = require("./ast/CaseExpression");
+Object.defineProperty(exports, "CaseExpression", { enumerable: true, get: function () { return CaseExpression_1.CaseExpression; } });
+var Column_1 = require("./ast/Column");
+Object.defineProperty(exports, "Column", { enumerable: true, get: function () { return Column_1.Column; } });
+var Concat_1 = require("./ast/Concat");
+Object.defineProperty(exports, "Concat", { enumerable: true, get: function () { return Concat_1.Concat; } });
+var ExistsExpression_1 = require("./ast/ExistsExpression");
+Object.defineProperty(exports, "ExistsExpression", { enumerable: true, get: function () { return ExistsExpression_1.ExistsExpression; } });
+var From_1 = require("./ast/From");
+Object.defineProperty(exports, "From", { enumerable: true, get: function () { return From_1.From; } });
+Object.defineProperty(exports, "TableFrom", { enumerable: true, get: function () { return From_1.TableFrom; } });
+Object.defineProperty(exports, "SubqueryFrom", { enumerable: true, get: function () { return From_1.SubqueryFrom; } });
+Object.defineProperty(exports, "JsonEachFrom", { enumerable: true, get: function () { return From_1.JsonEachFrom; } });
+var FunctionExpression_1 = require("./ast/FunctionExpression");
+Object.defineProperty(exports, "FunctionExpression", { enumerable: true, get: function () { return FunctionExpression_1.FunctionExpression; } });
+var InExpression_1 = require("./ast/InExpression");
+Object.defineProperty(exports, "InExpression", { enumerable: true, get: function () { return InExpression_1.InExpression; } });
+var InsertQuery_1 = require("./ast/InsertQuery");
+Object.defineProperty(exports, "InsertQuery", { enumerable: true, get: function () { return InsertQuery_1.InsertQuery; } });
+var Join_1 = require("./ast/Join");
+Object.defineProperty(exports, "Join", { enumerable: true, get: function () { return Join_1.Join; } });
+Object.defineProperty(exports, "JoinType", { enumerable: true, get: function () { return Join_1.JoinType; } });
+var Literals_1 = require("./ast/Literals");
+Object.defineProperty(exports, "LiteralExpression", { enumerable: true, get: function () { return Literals_1.LiteralExpression; } });
+Object.defineProperty(exports, "NumberLiteral", { enumerable: true, get: function () { return Literals_1.NumberLiteral; } });
+Object.defineProperty(exports, "StringLiteral", { enumerable: true, get: function () { return Literals_1.StringLiteral; } });
+Object.defineProperty(exports, "NullLiteral", { enumerable: true, get: function () { return Literals_1.NullLiteral; } });
+Object.defineProperty(exports, "Param", { enumerable: true, get: function () { return Literals_1.Param; } });
+var Operator_1 = require("./ast/Operator");
+Object.defineProperty(exports, "Operator", { enumerable: true, get: function () { return Operator_1.Operator; } });
+var OrderBy_1 = require("./ast/OrderBy");
+Object.defineProperty(exports, "OrderBy", { enumerable: true, get: function () { return OrderBy_1.OrderBy; } });
+Object.defineProperty(exports, "OrderByDirection", { enumerable: true, get: function () { return OrderBy_1.OrderByDirection; } });
+var SelectQuery_1 = require("./ast/SelectQuery");
+Object.defineProperty(exports, "SelectQuery", { enumerable: true, get: function () { return SelectQuery_1.SelectQuery; } });
+var UnaryExpression_1 = require("./ast/UnaryExpression");
+Object.defineProperty(exports, "UnaryExpression", { enumerable: true, get: function () { return UnaryExpression_1.UnaryExpression; } });
+var With_1 = require("./ast/With");
+Object.defineProperty(exports, "With", { enumerable: true, get: function () { return With_1.With; } });
+// Builder
+var QueryBuilder_1 = require("./builder/QueryBuilder");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return QueryBuilder_1.QueryBuilder; } });
+var Shorthand_1 = require("./builder/Shorthand");
+// Value helpers
+Object.defineProperty(exports, "VAL", { enumerable: true, get: function () { return Shorthand_1.VAL; } });
+// Operators
+Object.defineProperty(exports, "EQ", { enumerable: true, get: function () { return Shorthand_1.EQ; } });
+Object.defineProperty(exports, "NOT_EQ", { enumerable: true, get: function () { return Shorthand_1.NOT_EQ; } });
+Object.defineProperty(exports, "NOT", { enumerable: true, get: function () { return Shorthand_1.NOT; } });
+Object.defineProperty(exports, "GT", { enumerable: true, get: function () { return Shorthand_1.GT; } });
+Object.defineProperty(exports, "LT", { enumerable: true, get: function () { return Shorthand_1.LT; } });
+Object.defineProperty(exports, "GTE", { enumerable: true, get: function () { return Shorthand_1.GTE; } });
+Object.defineProperty(exports, "LTE", { enumerable: true, get: function () { return Shorthand_1.LTE; } });
+Object.defineProperty(exports, "LIKE", { enumerable: true, get: function () { return Shorthand_1.LIKE; } });
+Object.defineProperty(exports, "IS_NULL", { enumerable: true, get: function () { return Shorthand_1.IS_NULL; } });
+Object.defineProperty(exports, "IS_NOT_NULL", { enumerable: true, get: function () { return Shorthand_1.IS_NOT_NULL; } });
+Object.defineProperty(exports, "PLUS", { enumerable: true, get: function () { return Shorthand_1.PLUS; } });
+Object.defineProperty(exports, "MINUS", { enumerable: true, get: function () { return Shorthand_1.MINUS; } });
+Object.defineProperty(exports, "MULTIPLY", { enumerable: true, get: function () { return Shorthand_1.MULTIPLY; } });
+Object.defineProperty(exports, "DIVIDE", { enumerable: true, get: function () { return Shorthand_1.DIVIDE; } });
+Object.defineProperty(exports, "AND", { enumerable: true, get: function () { return Shorthand_1.AND; } });
+Object.defineProperty(exports, "OR", { enumerable: true, get: function () { return Shorthand_1.OR; } });
+// EXISTS
+Object.defineProperty(exports, "EXISTS", { enumerable: true, get: function () { return Shorthand_1.EXISTS; } });
+// Columns
+Object.defineProperty(exports, "COLUMN", { enumerable: true, get: function () { return Shorthand_1.COLUMN; } });
+// Select queries
+Object.defineProperty(exports, "SELECT", { enumerable: true, get: function () { return Shorthand_1.SELECT; } });
+Object.defineProperty(exports, "SELECT_DISTINCT", { enumerable: true, get: function () { return Shorthand_1.SELECT_DISTINCT; } });
+Object.defineProperty(exports, "FROM", { enumerable: true, get: function () { return Shorthand_1.FROM; } });
+Object.defineProperty(exports, "UNION", { enumerable: true, get: function () { return Shorthand_1.UNION; } });
+// Joins
+Object.defineProperty(exports, "JOIN", { enumerable: true, get: function () { return Shorthand_1.JOIN; } });
+Object.defineProperty(exports, "LEFT_JOIN", { enumerable: true, get: function () { return Shorthand_1.LEFT_JOIN; } });
+Object.defineProperty(exports, "CROSS_JOIN", { enumerable: true, get: function () { return Shorthand_1.CROSS_JOIN; } });
+// Functions
+Object.defineProperty(exports, "ABS", { enumerable: true, get: function () { return Shorthand_1.ABS; } });
+Object.defineProperty(exports, "COUNT", { enumerable: true, get: function () { return Shorthand_1.COUNT; } });
+Object.defineProperty(exports, "SUM", { enumerable: true, get: function () { return Shorthand_1.SUM; } });
+Object.defineProperty(exports, "FN", { enumerable: true, get: function () { return Shorthand_1.FN; } });
+Object.defineProperty(exports, "FN_DISTINCT", { enumerable: true, get: function () { return Shorthand_1.FN_DISTINCT; } });
+// Concatenation
+Object.defineProperty(exports, "CONCAT", { enumerable: true, get: function () { return Shorthand_1.CONCAT; } });
+// Parameters
+Object.defineProperty(exports, "PARAM", { enumerable: true, get: function () { return Shorthand_1.PARAM; } });
+// Insert queries
+Object.defineProperty(exports, "INSERT", { enumerable: true, get: function () { return Shorthand_1.INSERT; } });
+Object.defineProperty(exports, "INSERT_OR_REPLACE", { enumerable: true, get: function () { return Shorthand_1.INSERT_OR_REPLACE; } });
+// IN expressions
+Object.defineProperty(exports, "IN", { enumerable: true, get: function () { return Shorthand_1.IN; } });
+Object.defineProperty(exports, "NOT_IN", { enumerable: true, get: function () { return Shorthand_1.NOT_IN; } });
+// Clauses
+Object.defineProperty(exports, "GROUP_BY", { enumerable: true, get: function () { return Shorthand_1.GROUP_BY; } });
+Object.defineProperty(exports, "HAVING", { enumerable: true, get: function () { return Shorthand_1.HAVING; } });
+Object.defineProperty(exports, "ORDER_BY", { enumerable: true, get: function () { return Shorthand_1.ORDER_BY; } });
+// CASE expressions
+Object.defineProperty(exports, "CASE", { enumerable: true, get: function () { return Shorthand_1.CASE; } });
+// WITH clauses
+Object.defineProperty(exports, "WITH", { enumerable: true, get: function () { return Shorthand_1.WITH; } });
+// Renderers
+var QueryRenderer_1 = require("./renderer/QueryRenderer");
+Object.defineProperty(exports, "quoteIdentifier", { enumerable: true, get: function () { return QueryRenderer_1.quoteIdentifier; } });
+Object.defineProperty(exports, "shouldQuoteIdentifier", { enumerable: true, get: function () { return QueryRenderer_1.shouldQuoteIdentifier; } });
+var CompactQueryRenderer_1 = require("./renderer/CompactQueryRenderer");
+Object.defineProperty(exports, "CompactQueryRenderer", { enumerable: true, get: function () { return CompactQueryRenderer_1.CompactQueryRenderer; } });
+var IndentedQueryRenderer_1 = require("./renderer/IndentedQueryRenderer");
+Object.defineProperty(exports, "IndentedQueryRenderer", { enumerable: true, get: function () { return IndentedQueryRenderer_1.IndentedQueryRenderer; } });
+var CommonQueryValidator_1 = require("./validate/CommonQueryValidator");
+Object.defineProperty(exports, "CommonQueryValidator", { enumerable: true, get: function () { return CommonQueryValidator_1.CommonQueryValidator; } });
+var SQLiteQueryValidator_1 = require("./validate/SQLiteQueryValidator");
+Object.defineProperty(exports, "SQLiteQueryValidator", { enumerable: true, get: function () { return SQLiteQueryValidator_1.SQLiteQueryValidator; } });
+// Visitors
+var SqlTreeNodeVisitor_1 = require("./visitor/SqlTreeNodeVisitor");
+Object.defineProperty(exports, "FromLikeAndJoinVisitorAcceptor", { enumerable: true, get: function () { return SqlTreeNodeVisitor_1.FromLikeAndJoinVisitorAcceptor; } });
+Object.defineProperty(exports, "ColumnLikeVisitorAcceptor", { enumerable: true, get: function () { return SqlTreeNodeVisitor_1.ColumnLikeVisitorAcceptor; } });
+var QueryIdentityTransformer_1 = require("./visitor/QueryIdentityTransformer");
+Object.defineProperty(exports, "QueryIdentityTransformer", { enumerable: true, get: function () { return QueryIdentityTransformer_1.QueryIdentityTransformer; } });
+var QueryParamRewriteTransformer_1 = require("./visitor/QueryParamRewriteTransformer");
+Object.defineProperty(exports, "QueryParamRewriteTransformer", { enumerable: true, get: function () { return QueryParamRewriteTransformer_1.QueryParamRewriteTransformer; } });
+var ParamCollector_1 = require("./visitor/ParamCollector");
+Object.defineProperty(exports, "ParamCollectingVisitor", { enumerable: true, get: function () { return ParamCollector_1.ParamCollectingVisitor; } });
+//# sourceMappingURL=data:application/json;base64,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