@shaxpir/squilt 1.0.0 → 1.1.0

package/dist/ast/CreateTableQuery.d.ts

@@ -0,0 +1,57 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { Expression, SqlTreeNode } from "./Abstractions";
+export type ColumnType = 'INTEGER' | 'TEXT' | 'REAL' | 'BLOB' | 'NUMERIC';
+export interface ForeignKeyReference {
+    table: string;
+    column: string;
+    onDelete?: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+    onUpdate?: 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+}
+export interface ColumnConstraints {
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    default?: string | number | null;
+    check?: Expression;
+    references?: ForeignKeyReference;
+}
+export interface ColumnDefinition {
+    name: string;
+    type: ColumnType;
+    constraints: ColumnConstraints;
+}
+export interface TableConstraint {
+    type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+    columns?: string[];
+    references?: ForeignKeyReference;
+    check?: Expression;
+    name?: string;
+}
+export declare class CreateTableQuery implements SqlTreeNode {
+    private _tableName;
+    private _columns;
+    private _tableConstraints;
+    private _ifNotExists;
+    private _withoutRowid;
+    private _strict;
+    constructor(tableName: string);
+    static create(tableName: string): CreateTableQuery;
+    column(name: string, type: ColumnType, constraints?: ColumnConstraints): CreateTableQuery;
+    primaryKey(...columns: string[]): CreateTableQuery;
+    unique(...columns: string[]): CreateTableQuery;
+    foreignKey(columns: string[], references: ForeignKeyReference): CreateTableQuery;
+    check(expression: Expression, name?: string): CreateTableQuery;
+    ifNotExists(): CreateTableQuery;
+    withoutRowid(): CreateTableQuery;
+    strict(): CreateTableQuery;
+    get tableName(): string;
+    get columns(): ColumnDefinition[];
+    get tableConstraints(): TableConstraint[];
+    get hasIfNotExists(): boolean;
+    get hasWithoutRowid(): boolean;
+    get isStrict(): boolean;
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/CreateTableQuery.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTableQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents a CREATE TABLE statement
+class CreateTableQuery {
+    constructor(tableName) {
+        this._columns = [];
+        this._tableConstraints = [];
+        this._ifNotExists = false;
+        this._withoutRowid = false;
+        this._strict = false;
+        this._tableName = tableName;
+    }
+    static create(tableName) {
+        return new CreateTableQuery(tableName);
+    }
+    column(name, type, constraints = {}) {
+        this._columns.push({ name, type, constraints });
+        return this;
+    }
+    primaryKey(...columns) {
+        this._tableConstraints.push({ type: 'PRIMARY KEY', columns });
+        return this;
+    }
+    unique(...columns) {
+        this._tableConstraints.push({ type: 'UNIQUE', columns });
+        return this;
+    }
+    foreignKey(columns, references) {
+        this._tableConstraints.push({ type: 'FOREIGN KEY', columns, references });
+        return this;
+    }
+    check(expression, name) {
+        this._tableConstraints.push({ type: 'CHECK', check: expression, name });
+        return this;
+    }
+    ifNotExists() {
+        this._ifNotExists = true;
+        return this;
+    }
+    withoutRowid() {
+        this._withoutRowid = true;
+        return this;
+    }
+    strict() {
+        this._strict = true;
+        return this;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get tableConstraints() {
+        return this._tableConstraints;
+    }
+    get hasIfNotExists() {
+        return this._ifNotExists;
+    }
+    get hasWithoutRowid() {
+        return this._withoutRowid;
+    }
+    get isStrict() {
+        return this._strict;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitCreateTableQuery(this);
+    }
+}
+exports.CreateTableQuery = CreateTableQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/CreateViewQuery.d.ts

@@ -0,0 +1,34 @@
+import { SqlTreeNode } from "./Abstractions";
+import { SelectQuery } from "./SelectQuery";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+export declare class CreateViewQuery implements SqlTreeNode {
+    private _viewName;
+    private _columns;
+    private _selectQuery;
+    private _ifNotExists;
+    private _isTemporary;
+    constructor(viewName: string);
+    get viewName(): string;
+    get columns(): string[];
+    get selectQuery(): SelectQuery | null;
+    get hasIfNotExists(): boolean;
+    get isTemporary(): boolean;
+    /**
+     * Specify column names for the view (optional).
+     * If not specified, column names are derived from the SELECT query.
+     */
+    withColumns(...columns: string[]): CreateViewQuery;
+    /**
+     * Define the view's SELECT query.
+     */
+    as(query: SelectQuery): CreateViewQuery;
+    /**
+     * Add IF NOT EXISTS modifier.
+     */
+    ifNotExists(): CreateViewQuery;
+    /**
+     * Create a temporary view.
+     */
+    temporary(): CreateViewQuery;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/CreateViewQuery.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateViewQuery = void 0;
+class CreateViewQuery {
+    constructor(viewName) {
+        this._columns = [];
+        this._selectQuery = null;
+        this._ifNotExists = false;
+        this._isTemporary = false;
+        this._viewName = viewName;
+    }
+    get viewName() {
+        return this._viewName;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get selectQuery() {
+        return this._selectQuery;
+    }
+    get hasIfNotExists() {
+        return this._ifNotExists;
+    }
+    get isTemporary() {
+        return this._isTemporary;
+    }
+    /**
+     * Specify column names for the view (optional).
+     * If not specified, column names are derived from the SELECT query.
+     */
+    withColumns(...columns) {
+        this._columns = columns;
+        return this;
+    }
+    /**
+     * Define the view's SELECT query.
+     */
+    as(query) {
+        this._selectQuery = query;
+        return this;
+    }
+    /**
+     * Add IF NOT EXISTS modifier.
+     */
+    ifNotExists() {
+        this._ifNotExists = true;
+        return this;
+    }
+    /**
+     * Create a temporary view.
+     */
+    temporary() {
+        this._isTemporary = true;
+        return this;
+    }
+    accept(visitor) {
+        return visitor.visitCreateViewQuery(this);
+    }
+}
+exports.CreateViewQuery = CreateViewQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/CreateVirtualTableQuery.d.ts

@@ -0,0 +1,32 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { SqlTreeNode } from "./Abstractions";
+export type VirtualTableModule = 'fts5';
+export interface FTS5Options {
+    tokenize?: string;
+    content?: string;
+    contentRowid?: string;
+    prefix?: string;
+}
+export declare class CreateVirtualTableQuery implements SqlTreeNode {
+    private _tableName;
+    private _module;
+    private _columns;
+    private _options;
+    private _ifNotExists;
+    constructor(tableName: string, module: VirtualTableModule);
+    static create(tableName: string, module: VirtualTableModule): CreateVirtualTableQuery;
+    column(name: string): CreateVirtualTableQuery;
+    tokenize(tokenizer: string): CreateVirtualTableQuery;
+    content(tableName: string): CreateVirtualTableQuery;
+    contentRowid(columnName: string): CreateVirtualTableQuery;
+    prefix(lengths: string): CreateVirtualTableQuery;
+    ifNotExists(): CreateVirtualTableQuery;
+    get tableName(): string;
+    get module(): VirtualTableModule;
+    get columns(): string[];
+    get options(): FTS5Options;
+    get hasIfNotExists(): boolean;
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/CreateVirtualTableQuery.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateVirtualTableQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents a CREATE VIRTUAL TABLE statement
+class CreateVirtualTableQuery {
+    constructor(tableName, module) {
+        this._columns = [];
+        this._options = {};
+        this._ifNotExists = false;
+        this._tableName = tableName;
+        this._module = module;
+    }
+    static create(tableName, module) {
+        return new CreateVirtualTableQuery(tableName, module);
+    }
+    // Add a column to the virtual table
+    column(name) {
+        this._columns.push(name);
+        return this;
+    }
+    // Set the tokenizer for FTS5
+    tokenize(tokenizer) {
+        this._options.tokenize = tokenizer;
+        return this;
+    }
+    // Set the external content table for FTS5
+    content(tableName) {
+        this._options.content = tableName;
+        return this;
+    }
+    // Set the content_rowid column for external content FTS5 tables
+    contentRowid(columnName) {
+        this._options.contentRowid = columnName;
+        return this;
+    }
+    // Set prefix index lengths for FTS5
+    prefix(lengths) {
+        this._options.prefix = lengths;
+        return this;
+    }
+    // Add IF NOT EXISTS clause
+    ifNotExists() {
+        this._ifNotExists = true;
+        return this;
+    }
+    // Getters
+    get tableName() {
+        return this._tableName;
+    }
+    get module() {
+        return this._module;
+    }
+    get columns() {
+        return this._columns;
+    }
+    get options() {
+        return this._options;
+    }
+    get hasIfNotExists() {
+        return this._ifNotExists;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitCreateVirtualTableQuery(this);
+    }
+}
+exports.CreateVirtualTableQuery = CreateVirtualTableQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/DeleteQuery.d.ts

@@ -0,0 +1,17 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { AliasableExpression, Expression, SqlTreeNode } from "./Abstractions";
+export declare class DeleteQuery implements SqlTreeNode {
+    private _tableName;
+    private _where;
+    private _returning;
+    constructor(tableName: string);
+    static create(tableName: string): DeleteQuery;
+    where(condition: Expression): DeleteQuery;
+    returning(...expressions: AliasableExpression[]): DeleteQuery;
+    get tableName(): string;
+    get whereClause(): Expression | null;
+    get returningClause(): AliasableExpression[];
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/DeleteQuery.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents a DELETE statement with a table and optional WHERE clause
+class DeleteQuery {
+    constructor(tableName) {
+        this._where = null;
+        this._returning = [];
+        this._tableName = tableName;
+    }
+    static create(tableName) {
+        return new DeleteQuery(tableName);
+    }
+    where(condition) {
+        this._where = condition;
+        return this;
+    }
+    returning(...expressions) {
+        this._returning = expressions;
+        return this;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+    get whereClause() {
+        return this._where;
+    }
+    get returningClause() {
+        return this._returning;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitDeleteQuery(this);
+    }
+}
+exports.DeleteQuery = DeleteQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/DropIndexQuery.d.ts

@@ -0,0 +1,14 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { SqlTreeNode } from "./Abstractions";
+export declare class DropIndexQuery implements SqlTreeNode {
+    private _indexName;
+    private _ifExists;
+    constructor(indexName: string);
+    static create(indexName: string): DropIndexQuery;
+    ifExists(): DropIndexQuery;
+    get indexName(): string;
+    get hasIfExists(): boolean;
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/DropIndexQuery.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropIndexQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents a DROP INDEX statement
+class DropIndexQuery {
+    constructor(indexName) {
+        this._ifExists = false;
+        this._indexName = indexName;
+    }
+    static create(indexName) {
+        return new DropIndexQuery(indexName);
+    }
+    ifExists() {
+        this._ifExists = true;
+        return this;
+    }
+    get indexName() {
+        return this._indexName;
+    }
+    get hasIfExists() {
+        return this._ifExists;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitDropIndexQuery(this);
+    }
+}
+exports.DropIndexQuery = DropIndexQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/DropTableQuery.d.ts

@@ -0,0 +1,14 @@
+import { QueryRenderer } from "../renderer/QueryRenderer";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+import { SqlTreeNode } from "./Abstractions";
+export declare class DropTableQuery implements SqlTreeNode {
+    private _tableName;
+    private _ifExists;
+    constructor(tableName: string);
+    static create(tableName: string): DropTableQuery;
+    ifExists(): DropTableQuery;
+    get tableName(): string;
+    get hasIfExists(): boolean;
+    toSQL(renderer?: QueryRenderer): string;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/DropTableQuery.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTableQuery = void 0;
+const IndentedQueryRenderer_1 = require("../renderer/IndentedQueryRenderer");
+// Represents a DROP TABLE statement
+class DropTableQuery {
+    constructor(tableName) {
+        this._ifExists = false;
+        this._tableName = tableName;
+    }
+    static create(tableName) {
+        return new DropTableQuery(tableName);
+    }
+    ifExists() {
+        this._ifExists = true;
+        return this;
+    }
+    get tableName() {
+        return this._tableName;
+    }
+    get hasIfExists() {
+        return this._ifExists;
+    }
+    toSQL(renderer) {
+        if (!renderer) {
+            renderer = new IndentedQueryRenderer_1.IndentedQueryRenderer(2);
+        }
+        return this.accept(renderer);
+    }
+    accept(visitor) {
+        return visitor.visitDropTableQuery(this);
+    }
+}
+exports.DropTableQuery = DropTableQuery;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ast/DropViewQuery.d.ts

@@ -0,0 +1,11 @@
+import { SqlTreeNode } from "./Abstractions";
+import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
+export declare class DropViewQuery implements SqlTreeNode {
+    private _viewName;
+    private _ifExists;
+    constructor(viewName: string);
+    get viewName(): string;
+    get hasIfExists(): boolean;
+    ifExists(): DropViewQuery;
+    accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+}

package/dist/ast/DropViewQuery.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropViewQuery = void 0;
+class DropViewQuery {
+    constructor(viewName) {
+        this._ifExists = false;
+        this._viewName = viewName;
+    }
+    get viewName() {
+        return this._viewName;
+    }
+    get hasIfExists() {
+        return this._ifExists;
+    }
+    ifExists() {
+        this._ifExists = true;
+        return this;
+    }
+    accept(visitor) {
+        return visitor.visitDropViewQuery(this);
+    }
+}
+exports.DropViewQuery = DropViewQuery;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRHJvcFZpZXdRdWVyeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hc3QvRHJvcFZpZXdRdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQSxNQUFhLGFBQWE7SUFJeEIsWUFBWSxRQUFnQjtRQUZwQixjQUFTLEdBQVksS0FBSyxDQUFDO1FBR2pDLElBQUksQ0FBQyxTQUFTLEdBQUcsUUFBUSxDQUFDO0lBQzVCLENBQUM7SUFFRCxJQUFXLFFBQVE7UUFDakIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7SUFFRCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7SUFFTSxRQUFRO1FBQ2IsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDdEIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRU0sTUFBTSxDQUFJLE9BQThCO1FBQzdDLE9BQU8sT0FBTyxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzFDLENBQUM7Q0FDRjtBQXhCRCxzQ0F3QkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTcWxUcmVlTm9kZSB9IGZyb20gXCIuL0Fic3RyYWN0aW9uc1wiO1xuaW1wb3J0IHsgU3FsVHJlZU5vZGVWaXNpdG9yIH0gZnJvbSBcIi4uL3Zpc2l0b3IvU3FsVHJlZU5vZGVWaXNpdG9yXCI7XG5cbmV4cG9ydCBjbGFzcyBEcm9wVmlld1F1ZXJ5IGltcGxlbWVudHMgU3FsVHJlZU5vZGUge1xuICBwcml2YXRlIF92aWV3TmFtZTogc3RyaW5nO1xuICBwcml2YXRlIF9pZkV4aXN0czogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIGNvbnN0cnVjdG9yKHZpZXdOYW1lOiBzdHJpbmcpIHtcbiAgICB0aGlzLl92aWV3TmFtZSA9IHZpZXdOYW1lO1xuICB9XG5cbiAgcHVibGljIGdldCB2aWV3TmFtZSgpOiBzdHJpbmcge1xuICAgIHJldHVybiB0aGlzLl92aWV3TmFtZTtcbiAgfVxuXG4gIHB1YmxpYyBnZXQgaGFzSWZFeGlzdHMoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuX2lmRXhpc3RzO1xuICB9XG5cbiAgcHVibGljIGlmRXhpc3RzKCk6IERyb3BWaWV3UXVlcnkge1xuICAgIHRoaXMuX2lmRXhpc3RzID0gdHJ1ZTtcbiAgICByZXR1cm4gdGhpcztcbiAgfVxuXG4gIHB1YmxpYyBhY2NlcHQ8VD4odmlzaXRvcjogU3FsVHJlZU5vZGVWaXNpdG9yPFQ+KTogVCB7XG4gICAgcmV0dXJuIHZpc2l0b3IudmlzaXREcm9wVmlld1F1ZXJ5KHRoaXMpO1xuICB9XG59XG4iXX0=

package/dist/ast/FunctionExpression.d.ts

@@ -1,6 +1,8 @@
 import { SqlTreeNodeVisitor } from "../visitor/SqlTreeNodeVisitor";
 import { AliasableExpression, Expression } from "./Abstractions";
 import { FunctionName } from "./FunctionName";
+import { OrderBy } from "./OrderBy";
+import { WindowExpression } from "./WindowExpression";
 export declare class FunctionExpression extends AliasableExpression {
     private _name;
     private _args;
@@ -10,4 +12,23 @@ export declare class FunctionExpression extends AliasableExpression {
     get args(): Expression[];
     get distinct(): boolean;
     accept<T>(visitor: SqlTreeNodeVisitor<T>): T;
+    /**
+     * Create a window function expression with an OVER clause.
+     *
+     * Accepts PARTITION_BY (Expression[]) and ORDER_BY (OrderBy) arguments
+     * in any order. Multiple ORDER_BY clauses are combined.
+     *
+     * @example
+     * ```typescript
+     * // With ORDER BY only
+     * FN('ROW_NUMBER').over(ORDER_BY('created_at'))
+     *
+     * // With PARTITION BY and ORDER BY
+     * FN('RANK').over(PARTITION_BY('category'), ORDER_BY('price', DESC))
+     *
+     * // Empty OVER clause (window over entire result set)
+     * FN('AVG', COLUMN('salary')).over()
+     * ```
+     */
+    over(...specs: (Expression[] | OrderBy)[]): WindowExpression;
 }