sumak 0.0.4 → 0.0.6

package/dist/builder/delete.mjs

@@ -0,0 +1,113 @@
+import { createDeleteNode } from "../ast/nodes.mjs";
+export class DeleteBuilder {
+	node;
+	constructor(node) {
+		this.node = node ?? createDeleteNode({
+			type: "table_ref",
+			name: ""
+		});
+	}
+	from(table) {
+		const ref = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		return new DeleteBuilder({
+			...this.node,
+			table: ref
+		});
+	}
+	where(expr) {
+		if (this.node.where) {
+			return new DeleteBuilder({
+				...this.node,
+				where: {
+					type: "binary_op",
+					op: "AND",
+					left: this.node.where,
+					right: expr
+				}
+			});
+		}
+		return new DeleteBuilder({
+			...this.node,
+			where: expr
+		});
+	}
+	
+	using(table) {
+		const ref = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		return new DeleteBuilder({
+			...this.node,
+			using: ref
+		});
+	}
+	
+	join(type, table, on) {
+		const tableRef = typeof table === "string" ? {
+			type: "table_ref",
+			name: table
+		} : table;
+		const join = {
+			type: "join",
+			joinType: type,
+			table: tableRef,
+			on
+		};
+		return new DeleteBuilder({
+			...this.node,
+			joins: [...this.node.joins, join]
+		});
+	}
+	innerJoin(table, on) {
+		return this.join("INNER", table, on);
+	}
+	leftJoin(table, on) {
+		return this.join("LEFT", table, on);
+	}
+	orderBy(expr, direction = "ASC") {
+		const node = {
+			expr: typeof expr === "string" ? {
+				type: "column_ref",
+				column: expr
+			} : expr,
+			direction
+		};
+		return new DeleteBuilder({
+			...this.node,
+			orderBy: [...this.node.orderBy ?? [], node]
+		});
+	}
+	limit(n) {
+		return new DeleteBuilder({
+			...this.node,
+			limit: n
+		});
+	}
+	returning(...exprs) {
+		return new DeleteBuilder({
+			...this.node,
+			returning: [...this.node.returning, ...exprs]
+		});
+	}
+	with(name, query, recursive = false) {
+		const cte = {
+			name,
+			query,
+			recursive
+		};
+		return new DeleteBuilder({
+			...this.node,
+			ctes: [...this.node.ctes, cte]
+		});
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+export function deleteFrom(table) {
+	return new DeleteBuilder().from(table);
+}

package/dist/builder/eb.d.mts

@@ -0,0 +1,312 @@
+import type { FrameBound, FullTextSearchMode, SelectNode } from "../ast/nodes.mjs";
+import type { Expression } from "../ast/typed-expression.mjs";
+import type { SelectType } from "../schema/types.mjs";
+/**
+* A typed column reference that exposes comparison methods.
+*
+* ```ts
+* // users.id.eq(42) → ("id" = $1) with param [42]
+* // users.name.like("%ali%") → ("name" LIKE '%ali%')
+* ```
+*/
+export declare class Col<T> {
+	readonly _type: T;
+	constructor(column: string, table?: string);
+	/** = */
+	eq(value: T): Expression<boolean>;
+	/** != */
+	neq(value: T): Expression<boolean>;
+	/** > */
+	gt(value: T): Expression<boolean>;
+	/** >= */
+	gte(value: T): Expression<boolean>;
+	/** < */
+	lt(value: T): Expression<boolean>;
+	/** <= */
+	lte(value: T): Expression<boolean>;
+	/** LIKE (string columns only) */
+	like(this: Col<string>, pattern: string): Expression<boolean>;
+	/** NOT LIKE */
+	notLike(this: Col<string>, pattern: string): Expression<boolean>;
+	/** ILIKE — case-insensitive LIKE (PG) */
+	ilike(this: Col<string>, pattern: string): Expression<boolean>;
+	/** NOT ILIKE (PG) */
+	notIlike(this: Col<string>, pattern: string): Expression<boolean>;
+	/** IN (value1, value2, ...) */
+	in(values: T[]): Expression<boolean>;
+	/** NOT IN */
+	notIn(values: T[]): Expression<boolean>;
+	/** IS NULL */
+	isNull(): Expression<boolean>;
+	/** IS NOT NULL */
+	isNotNull(): Expression<boolean>;
+	/** BETWEEN low AND high */
+	between(low: T, high: T): Expression<boolean>;
+	/** NOT BETWEEN low AND high */
+	notBetween(low: T, high: T): Expression<boolean>;
+	/** BETWEEN SYMMETRIC low AND high (PG) — order-independent range check */
+	betweenSymmetric(low: T, high: T): Expression<boolean>;
+	/** IN (SELECT ...) — subquery */
+	inSubquery(query: SelectNode): Expression<boolean>;
+	/** NOT IN (SELECT ...) — subquery */
+	notInSubquery(query: SelectNode): Expression<boolean>;
+	/** = with Expression value */
+	eqExpr(value: Expression<T>): Expression<boolean>;
+	/** != with Expression value */
+	neqExpr(value: Expression<T>): Expression<boolean>;
+	/** > with Expression value */
+	gtExpr(value: Expression<T>): Expression<boolean>;
+	/** >= with Expression value */
+	gteExpr(value: Expression<T>): Expression<boolean>;
+	/** < with Expression value */
+	ltExpr(value: Expression<T>): Expression<boolean>;
+	/** <= with Expression value */
+	lteExpr(value: Expression<T>): Expression<boolean>;
+	/** IS DISTINCT FROM — null-safe inequality */
+	isDistinctFrom(value: T): Expression<boolean>;
+	/** IS NOT DISTINCT FROM — null-safe equality */
+	isNotDistinctFrom(value: T): Expression<boolean>;
+	/** Compare with another column: col1.eqCol(col2) */
+	eqCol(other: Col<T>): Expression<boolean>;
+	/** != another column */
+	neqCol(other: Col<T>): Expression<boolean>;
+	/** > another column */
+	gtCol(other: Col<T>): Expression<boolean>;
+	/** < another column */
+	ltCol(other: Col<T>): Expression<boolean>;
+	/** >= another column */
+	gteCol(other: Col<T>): Expression<boolean>;
+	/** <= another column */
+	lteCol(other: Col<T>): Expression<boolean>;
+	/** As raw Expression<T> for advanced use */
+	toExpr(): Expression<T>;
+}
+export declare function resetParams(): void;
+/**
+* Create typed column proxies for a table's columns.
+*
+* Type: { id: Col<number>, name: Col<string>, ... }
+*/
+export type ColumnProxies<
+	DB,
+	TB extends keyof DB
+> = { [K in keyof DB[TB] & string] : Col<SelectType<DB[TB][K]>> };
+/**
+* Create column proxy objects for use in where/on callbacks.
+*/
+export declare function createColumnProxies<
+	DB,
+	TB extends keyof DB
+>(_table: TB & string): ColumnProxies<DB, TB>;
+/**
+* Expression builder callback type.
+*
+* ```ts
+* .where(({ id, name }) => id.eq(42))
+* ```
+*/
+export type WhereCallback<
+	DB,
+	TB extends keyof DB
+> = (cols: ColumnProxies<DB, TB>) => Expression<boolean>;
+/** AND expressions — variadic: and(a, b) or and(a, b, c, ...) */
+export declare function and(...exprs: Expression<boolean>[]): Expression<boolean>;
+/** OR expressions — variadic: or(a, b) or or(a, b, c, ...) */
+export declare function or(...exprs: Expression<boolean>[]): Expression<boolean>;
+/** Raw literal value as expression */
+export declare function val<T extends string | number | boolean | null>(value: T): Expression<T>;
+/**
+* Raw SQL expression — escape hatch for arbitrary SQL in expressions.
+*
+* ```ts
+* .where(() => rawExpr("age > 18"))
+* .selectExpr(rawExpr<number>("EXTRACT(YEAR FROM created_at)"), "year")
+* ```
+*/
+export declare function rawExpr<T = unknown>(sql: string, params?: unknown[]): Expression<T>;
+/** SQL function call */
+export declare function sqlFn(name: string, ...args: Expression<any>[]): Expression<any>;
+/** COUNT(*) */
+export declare function count(): Expression<number>;
+/** COUNT(DISTINCT expr) */
+export declare function countDistinct(expr: Expression<any>): Expression<number>;
+/** SUM(expr) */
+export declare function sum(expr: Expression<number>): Expression<number>;
+/** SUM(DISTINCT expr) */
+export declare function sumDistinct(expr: Expression<number>): Expression<number>;
+/** AVG(expr) */
+export declare function avg(expr: Expression<number>): Expression<number>;
+/** AVG(DISTINCT expr) */
+export declare function avgDistinct(expr: Expression<number>): Expression<number>;
+/** MIN(expr) */
+export declare function min<T>(expr: Expression<T>): Expression<T>;
+/** MAX(expr) */
+export declare function max<T>(expr: Expression<T>): Expression<T>;
+/** COALESCE(a, b, c, ...) — returns first non-null value */
+export declare function coalesce<T>(...args: Expression<T | null>[]): Expression<T>;
+/** NOT expr */
+export declare function not(expr: Expression<boolean>): Expression<boolean>;
+/** Add: a + b */
+export declare function add(a: Expression<number>, b: Expression<number>): Expression<number>;
+/** Subtract: a - b */
+export declare function sub(a: Expression<number>, b: Expression<number>): Expression<number>;
+/** Multiply: a * b */
+export declare function mul(a: Expression<number>, b: Expression<number>): Expression<number>;
+/** Divide: a / b */
+export declare function div(a: Expression<number>, b: Expression<number>): Expression<number>;
+/** Modulo: a % b */
+export declare function mod(a: Expression<number>, b: Expression<number>): Expression<number>;
+/** Unary minus: -expr */
+export declare function neg(expr: Expression<number>): Expression<number>;
+/** EXISTS (subquery) */
+export declare function exists(query: SelectNode): Expression<boolean>;
+/** NOT EXISTS (subquery) */
+export declare function notExists(query: SelectNode): Expression<boolean>;
+/** CAST(expr AS type) */
+export declare function cast<T>(expr: Expression<any>, dataType: string): Expression<T>;
+/**
+* JSON access operator: expr->path, expr->>path, etc.
+*
+* ```ts
+* jsonRef(cols.data, "name", "->>")  // data->>'name'
+* ```
+*/
+export declare function jsonRef<T = unknown>(expr: Expression<any>, path: string, operator?: "->" | "->>" | "#>" | "#>>"): Expression<T>;
+/**
+* Full-text search expression.
+*
+* Dialect-aware: PG uses tsvector/tsquery, MySQL uses MATCH/AGAINST,
+* SQLite uses FTS5 MATCH, MSSQL uses CONTAINS/FREETEXT.
+*
+* ```ts
+* // PostgreSQL: to_tsvector("name") @@ to_tsquery($1)
+* .where(() => textSearch([cols.name], val("alice")))
+*
+* // MySQL: MATCH(`name`) AGAINST(? IN BOOLEAN MODE)
+* .where(() => textSearch([cols.name], val("alice"), { mode: "boolean" }))
+* ```
+*/
+export declare function textSearch(columns: Expression<any>[], query: Expression<any>, options?: {
+	mode?: FullTextSearchMode;
+	language?: string;
+}): Expression<boolean>;
+/**
+* CASE expression builder.
+*
+* ```ts
+* case_()
+*   .when(cols.status.eq("active"), val(1))
+*   .when(cols.status.eq("inactive"), val(0))
+*   .else_(val(-1))
+*   .end()
+* ```
+*/
+export declare function case_(operand?: Expression<any>): CaseBuilder<never>;
+export declare class CaseBuilder<T> {
+	when<R>(condition: Expression<boolean>, result: Expression<R>): CaseBuilder<T | R>;
+	else_<R>(result: Expression<R>): CaseBuilder<T | R>;
+	end(): Expression<T>;
+}
+/**
+* Window function builder.
+*
+* ```ts
+* over(count(), w => w.partitionBy("dept").orderBy("salary", "DESC"))
+* over(sqlFn("ROW_NUMBER"), w => w.partitionBy("dept").orderBy("id"))
+* ```
+*/
+export declare function over<T>(fn: Expression<T>, build: (w: WindowBuilder) => WindowBuilder): Expression<T>;
+export declare class WindowBuilder {
+	partitionBy(...columns: string[]): WindowBuilder;
+	orderBy(column: string, direction?: "ASC" | "DESC"): WindowBuilder;
+	rows(start: FrameBound, end?: FrameBound): WindowBuilder;
+	range(start: FrameBound, end?: FrameBound): WindowBuilder;
+	groups(start: FrameBound, end?: FrameBound): WindowBuilder;
+}
+/** ROW_NUMBER() — must be used with over() */
+export declare function rowNumber(): Expression<number>;
+/** RANK() — must be used with over() */
+export declare function rank(): Expression<number>;
+/** DENSE_RANK() — must be used with over() */
+export declare function denseRank(): Expression<number>;
+/** LAG(expr, offset?, default?) */
+export declare function lag<T>(expr: Expression<T>, offset?: number, defaultValue?: Expression<T>): Expression<T>;
+/** LEAD(expr, offset?, default?) */
+export declare function lead<T>(expr: Expression<T>, offset?: number, defaultValue?: Expression<T>): Expression<T>;
+/** NTILE(n) */
+export declare function ntile(n: number): Expression<number>;
+/** UPPER(expr) */
+export declare function upper(expr: Expression<string>): Expression<string>;
+/** LOWER(expr) */
+export declare function lower(expr: Expression<string>): Expression<string>;
+/** CONCAT(a, b, ...) */
+export declare function concat(...args: Expression<string>[]): Expression<string>;
+/** SUBSTRING(expr, start, length?) */
+export declare function substring(expr: Expression<string>, start: number, length?: number): Expression<string>;
+/** TRIM(expr) */
+export declare function trim(expr: Expression<string>): Expression<string>;
+/** LENGTH(expr) / CHAR_LENGTH(expr) */
+export declare function length(expr: Expression<string>): Expression<number>;
+/** NOW() */
+export declare function now(): Expression<Date>;
+/** CURRENT_TIMESTAMP */
+export declare function currentTimestamp(): Expression<Date>;
+/** NULLIF(a, b) */
+export declare function nullif<T>(a: Expression<T>, b: Expression<T>): Expression<T | null>;
+/** GREATEST(a, b, ...) */
+export declare function greatest<T>(...args: Expression<T>[]): Expression<T>;
+/** LEAST(a, b, ...) */
+export declare function least<T>(...args: Expression<T>[]): Expression<T>;
+/** ABS(expr) */
+export declare function abs(expr: Expression<number>): Expression<number>;
+/** ROUND(expr, precision?) */
+export declare function round(expr: Expression<number>, precision?: number): Expression<number>;
+/** CEIL(expr) */
+export declare function ceil(expr: Expression<number>): Expression<number>;
+/** JSON_AGG(expr) — aggregate rows into JSON array (PG) */
+export declare function jsonAgg<T>(expr: Expression<T>): Expression<T[]>;
+/** TO_JSON(expr) — convert value to JSON (PG) */
+export declare function toJson<T>(expr: Expression<T>): Expression<unknown>;
+/** JSON_BUILD_OBJECT(key, value, ...) — build JSON object (PG) */
+export declare function jsonBuildObject(...pairs: [string, Expression<any>][]): Expression<Record<string, unknown>>;
+/** @> (array contains) */
+export declare function arrayContains(arr: Expression<any>, values: Expression<any>): Expression<boolean>;
+/** <@ (array contained by) */
+export declare function arrayContainedBy(arr: Expression<any>, values: Expression<any>): Expression<boolean>;
+/** && (array overlaps) */
+export declare function arrayOverlaps(arr: Expression<any>, values: Expression<any>): Expression<boolean>;
+/** FLOOR(expr) */
+export declare function floor(expr: Expression<number>): Expression<number>;
+/** STRING_AGG(expr, delimiter) — aggregate strings with separator */
+export declare function stringAgg(expr: Expression<string>, delimiter: string, orderBy?: {
+	expr: Expression<any>;
+	direction?: "ASC" | "DESC";
+}[]): Expression<string>;
+/** ARRAY_AGG(expr) — aggregate values into array */
+export declare function arrayAgg<T>(expr: Expression<T>, orderBy?: {
+	expr: Expression<any>;
+	direction?: "ASC" | "DESC";
+}[]): Expression<T[]>;
+/** Attach ORDER BY to an existing aggregate expression. */
+export declare function aggOrderBy<T>(agg: Expression<T>, orderBy: {
+	expr: Expression<any>;
+	direction?: "ASC" | "DESC";
+}[]): Expression<T>;
+/**
+* Row-value tuple for comparisons.
+*
+* ```ts
+* // (a, b) = (1, 2)
+* tuple(cols.a.toExpr(), cols.b.toExpr())
+* ```
+*/
+export declare function tuple(...exprs: Expression<any>[]): Expression<any>;
+/**
+* Attach FILTER (WHERE ...) to an aggregate expression.
+*
+* ```ts
+* filter(count(), ({ active }) => active.eq(true))
+* // COUNT(*) FILTER (WHERE "active" = $1)
+* ```
+*/
+export declare function filter<T>(agg: Expression<T>, condition: Expression<boolean>): Expression<T>;