sumak 0.0.6 → 0.0.7

package/dist/ast/ddl-nodes.d.mts

@@ -0,0 +1,153 @@
+import type { ExpressionNode, SelectNode, TableRefNode } from "./nodes.mjs";
+export type ForeignKeyAction = "NO ACTION" | "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT";
+export interface ColumnDefinitionNode {
+	type: "column_definition";
+	name: string;
+	dataType: string;
+	notNull?: boolean;
+	defaultTo?: ExpressionNode;
+	primaryKey?: boolean;
+	unique?: boolean;
+	check?: ExpressionNode;
+	autoIncrement?: boolean;
+	references?: {
+		table: string;
+		column: string;
+		onDelete?: ForeignKeyAction;
+		onUpdate?: ForeignKeyAction;
+	};
+	generatedAs?: {
+		expression: ExpressionNode;
+		stored?: boolean;
+	};
+}
+export interface PrimaryKeyConstraintNode {
+	type: "pk_constraint";
+	name?: string;
+	columns: string[];
+}
+export interface UniqueConstraintNode {
+	type: "unique_constraint";
+	name?: string;
+	columns: string[];
+}
+export interface CheckConstraintNode {
+	type: "check_constraint";
+	name?: string;
+	expression: ExpressionNode;
+}
+export interface ForeignKeyConstraintNode {
+	type: "fk_constraint";
+	name?: string;
+	columns: string[];
+	references: {
+		table: string;
+		columns: string[];
+		onDelete?: ForeignKeyAction;
+		onUpdate?: ForeignKeyAction;
+	};
+}
+export type TableConstraintNode = PrimaryKeyConstraintNode | UniqueConstraintNode | CheckConstraintNode | ForeignKeyConstraintNode;
+export interface CreateTableNode {
+	type: "create_table";
+	table: TableRefNode;
+	columns: ColumnDefinitionNode[];
+	constraints: TableConstraintNode[];
+	ifNotExists?: boolean;
+	temporary?: boolean;
+	asSelect?: SelectNode;
+}
+export type AlterTableAction = {
+	kind: "add_column";
+	column: ColumnDefinitionNode;
+} | {
+	kind: "drop_column";
+	column: string;
+} | {
+	kind: "rename_column";
+	from: string;
+	to: string;
+} | {
+	kind: "rename_table";
+	to: string;
+} | {
+	kind: "alter_column";
+	column: string;
+	set: AlterColumnSet;
+} | {
+	kind: "add_constraint";
+	constraint: TableConstraintNode;
+} | {
+	kind: "drop_constraint";
+	name: string;
+};
+export type AlterColumnSet = {
+	type: "set_not_null";
+} | {
+	type: "drop_not_null";
+} | {
+	type: "set_default";
+	value: ExpressionNode;
+} | {
+	type: "drop_default";
+} | {
+	type: "set_data_type";
+	dataType: string;
+};
+export interface AlterTableNode {
+	type: "alter_table";
+	table: TableRefNode;
+	actions: AlterTableAction[];
+}
+export interface DropTableNode {
+	type: "drop_table";
+	table: TableRefNode;
+	ifExists?: boolean;
+	cascade?: boolean;
+}
+export interface CreateIndexNode {
+	type: "create_index";
+	name: string;
+	table: string;
+	columns: {
+		column: string;
+		direction?: "ASC" | "DESC";
+	}[];
+	expressions?: ExpressionNode[];
+	unique?: boolean;
+	ifNotExists?: boolean;
+	using?: string;
+	where?: ExpressionNode;
+}
+export interface DropIndexNode {
+	type: "drop_index";
+	name: string;
+	table?: string;
+	ifExists?: boolean;
+	cascade?: boolean;
+}
+export interface CreateViewNode {
+	type: "create_view";
+	name: string;
+	schema?: string;
+	columns?: string[];
+	asSelect: SelectNode;
+	orReplace?: boolean;
+	temporary?: boolean;
+	materialized?: boolean;
+	ifNotExists?: boolean;
+}
+export interface DropViewNode {
+	type: "drop_view";
+	name: string;
+	ifExists?: boolean;
+	cascade?: boolean;
+	materialized?: boolean;
+}
+export interface TruncateTableNode {
+	type: "truncate_table";
+	table: TableRefNode;
+	cascade?: boolean;
+	restartIdentity?: boolean;
+}
+export type DDLNode = CreateTableNode | AlterTableNode | DropTableNode | CreateIndexNode | DropIndexNode | CreateViewNode | DropViewNode | TruncateTableNode;

package/dist/ast/ddl-nodes.mjs

@@ -0,0 +1 @@
+export {};

package/dist/builder/ddl/alter-table.d.mts

@@ -0,0 +1,25 @@
+import type { AlterColumnSet, AlterTableNode, ForeignKeyAction, ForeignKeyConstraintNode } from "../../ast/ddl-nodes.mjs";
+import { ColumnDefBuilder } from "./create-table.mjs";
+export declare class AlterTableBuilder {
+	private readonly node;
+	constructor(table: string, schema?: string);
+	private withAction;
+	addColumn(name: string, dataType: string, build?: (col: ColumnDefBuilder) => ColumnDefBuilder): AlterTableBuilder;
+	dropColumn(name: string): AlterTableBuilder;
+	renameColumn(from: string, to: string): AlterTableBuilder;
+	renameTo(newName: string): AlterTableBuilder;
+	alterColumn(column: string, set: AlterColumnSet): AlterTableBuilder;
+	addPrimaryKeyConstraint(name: string | undefined, columns: string[]): AlterTableBuilder;
+	addUniqueConstraint(name: string | undefined, columns: string[]): AlterTableBuilder;
+	addForeignKeyConstraint(name: string | undefined, columns: string[], refTable: string, refColumns: string[], build?: (fk: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder): AlterTableBuilder;
+	dropConstraint(name: string): AlterTableBuilder;
+	build(): AlterTableNode;
+}
+export declare class ForeignKeyConstraintBuilder {
+	private readonly node;
+	constructor(node: ForeignKeyConstraintNode);
+	onDelete(action: ForeignKeyAction): ForeignKeyConstraintBuilder;
+	onUpdate(action: ForeignKeyAction): ForeignKeyConstraintBuilder;
+	build(): ForeignKeyConstraintNode;
+}
+export declare function alterTable(table: string, schema?: string): AlterTableBuilder;

package/dist/builder/ddl/alter-table.mjs

@@ -0,0 +1,146 @@
+import { ColumnDefBuilder } from "./create-table.mjs";
+export class AlterTableBuilder {
+	node;
+	constructor(table, schema) {
+		const ref = {
+			type: "table_ref",
+			name: table,
+			schema
+		};
+		this.node = {
+			type: "alter_table",
+			table: ref,
+			actions: []
+		};
+	}
+	withAction(action) {
+		const next = new AlterTableBuilder(this.node.table.name, this.node.table.schema);
+		return Object.assign(next, { node: {
+			...this.node,
+			actions: [...this.node.actions, action]
+		} });
+	}
+	addColumn(name, dataType, build) {
+		let colBuilder = new ColumnDefBuilder(name, dataType);
+		if (build) {
+			colBuilder = build(colBuilder);
+		}
+		const colDef = colBuilder._build();
+		return this.withAction({
+			kind: "add_column",
+			column: colDef
+		});
+	}
+	dropColumn(name) {
+		return this.withAction({
+			kind: "drop_column",
+			column: name
+		});
+	}
+	renameColumn(from, to) {
+		return this.withAction({
+			kind: "rename_column",
+			from,
+			to
+		});
+	}
+	renameTo(newName) {
+		return this.withAction({
+			kind: "rename_table",
+			to: newName
+		});
+	}
+	alterColumn(column, set) {
+		return this.withAction({
+			kind: "alter_column",
+			column,
+			set
+		});
+	}
+	addPrimaryKeyConstraint(name, columns) {
+		const constraint = {
+			type: "pk_constraint",
+			name,
+			columns
+		};
+		return this.withAction({
+			kind: "add_constraint",
+			constraint
+		});
+	}
+	addUniqueConstraint(name, columns) {
+		const constraint = {
+			type: "unique_constraint",
+			name,
+			columns
+		};
+		return this.withAction({
+			kind: "add_constraint",
+			constraint
+		});
+	}
+	addForeignKeyConstraint(name, columns, refTable, refColumns, build) {
+		let constraint = {
+			type: "fk_constraint",
+			name,
+			columns,
+			references: {
+				table: refTable,
+				columns: refColumns
+			}
+		};
+		if (build) {
+			const builder = build(new ForeignKeyConstraintBuilder(constraint));
+			constraint = builder.build();
+		}
+		return this.withAction({
+			kind: "add_constraint",
+			constraint
+		});
+	}
+	dropConstraint(name) {
+		return this.withAction({
+			kind: "drop_constraint",
+			name
+		});
+	}
+	build() {
+		return {
+			...this.node,
+			actions: [...this.node.actions]
+		};
+	}
+}
+export class ForeignKeyConstraintBuilder {
+	node;
+	constructor(node) {
+		this.node = node;
+	}
+	onDelete(action) {
+		return new ForeignKeyConstraintBuilder({
+			...this.node,
+			references: {
+				...this.node.references,
+				onDelete: action
+			}
+		});
+	}
+	onUpdate(action) {
+		return new ForeignKeyConstraintBuilder({
+			...this.node,
+			references: {
+				...this.node.references,
+				onUpdate: action
+			}
+		});
+	}
+	build() {
+		return {
+			...this.node,
+			references: { ...this.node.references }
+		};
+	}
+}
+export function alterTable(table, schema) {
+	return new AlterTableBuilder(table, schema);
+}

package/dist/builder/ddl/create-index.d.mts

@@ -0,0 +1,19 @@
+import type { CreateIndexNode } from "../../ast/ddl-nodes.mjs";
+import type { ExpressionNode } from "../../ast/nodes.mjs";
+export declare class CreateIndexBuilder {
+	private readonly node;
+	constructor(name: string);
+	constructor(node: CreateIndexNode);
+	on(table: string): CreateIndexBuilder;
+	column(col: string, direction?: "ASC" | "DESC"): CreateIndexBuilder;
+	columns(cols: (string | {
+		column: string;
+		direction?: "ASC" | "DESC";
+	})[]): CreateIndexBuilder;
+	unique(): CreateIndexBuilder;
+	ifNotExists(): CreateIndexBuilder;
+	using(method: string): CreateIndexBuilder;
+	where(expr: ExpressionNode): CreateIndexBuilder;
+	build(): CreateIndexNode;
+}
+export declare function createIndex(name: string): CreateIndexBuilder;

package/dist/builder/ddl/create-index.mjs

@@ -0,0 +1,67 @@
+export class CreateIndexBuilder {
+	node;
+	constructor(nameOrNode) {
+		if (typeof nameOrNode === "string") {
+			this.node = {
+				type: "create_index",
+				name: nameOrNode,
+				table: "",
+				columns: []
+			};
+		} else {
+			this.node = nameOrNode;
+		}
+	}
+	on(table) {
+		return new CreateIndexBuilder({
+			...this.node,
+			table
+		});
+	}
+	column(col, direction) {
+		return new CreateIndexBuilder({
+			...this.node,
+			columns: [...this.node.columns, {
+				column: col,
+				direction
+			}]
+		});
+	}
+	columns(cols) {
+		const normalized = cols.map((c) => typeof c === "string" ? { column: c } : c);
+		return new CreateIndexBuilder({
+			...this.node,
+			columns: [...this.node.columns, ...normalized]
+		});
+	}
+	unique() {
+		return new CreateIndexBuilder({
+			...this.node,
+			unique: true
+		});
+	}
+	ifNotExists() {
+		return new CreateIndexBuilder({
+			...this.node,
+			ifNotExists: true
+		});
+	}
+	using(method) {
+		return new CreateIndexBuilder({
+			...this.node,
+			using: method
+		});
+	}
+	where(expr) {
+		return new CreateIndexBuilder({
+			...this.node,
+			where: expr
+		});
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+export function createIndex(name) {
+	return new CreateIndexBuilder(name);
+}

package/dist/builder/ddl/create-table.d.mts

@@ -0,0 +1,40 @@
+import type { CreateTableNode, ForeignKeyAction } from "../../ast/ddl-nodes.mjs";
+import type { ExpressionNode, SelectNode } from "../../ast/nodes.mjs";
+export declare class ForeignKeyBuilder {
+	private _onDelete?;
+	private _onUpdate?;
+	constructor(onDelete?: ForeignKeyAction, onUpdate?: ForeignKeyAction);
+	onDelete(action: ForeignKeyAction): ForeignKeyBuilder;
+	onUpdate(action: ForeignKeyAction): ForeignKeyBuilder;
+}
+export declare class ColumnDefBuilder {
+	private node;
+	constructor(name: string, dataType: string);
+	private clone;
+	notNull(): ColumnDefBuilder;
+	defaultTo(value: ExpressionNode): ColumnDefBuilder;
+	primaryKey(): ColumnDefBuilder;
+	unique(): ColumnDefBuilder;
+	check(expr: ExpressionNode): ColumnDefBuilder;
+	autoIncrement(): ColumnDefBuilder;
+	references(table: string, column: string): ColumnDefBuilder;
+	onDelete(action: ForeignKeyAction): ColumnDefBuilder;
+	onUpdate(action: ForeignKeyAction): ColumnDefBuilder;
+	generatedAlwaysAs(expr: ExpressionNode): ColumnDefBuilder;
+	stored(): ColumnDefBuilder;
+}
+export declare class CreateTableBuilder {
+	private node;
+	constructor(table: string, schema?: string);
+	private cloneWith;
+	ifNotExists(): CreateTableBuilder;
+	temporary(): CreateTableBuilder;
+	addColumn(name: string, dataType: string, build?: (col: ColumnDefBuilder) => ColumnDefBuilder): CreateTableBuilder;
+	addPrimaryKeyConstraint(name: string | undefined, columns: string[]): CreateTableBuilder;
+	addUniqueConstraint(name: string | undefined, columns: string[]): CreateTableBuilder;
+	addCheckConstraint(name: string | undefined, expression: ExpressionNode): CreateTableBuilder;
+	addForeignKeyConstraint(name: string | undefined, columns: string[], refTable: string, refColumns: string[], build?: (fk: ForeignKeyBuilder) => ForeignKeyBuilder): CreateTableBuilder;
+	asSelect(query: SelectNode): CreateTableBuilder;
+	build(): CreateTableNode;
+}
+export declare function createTable(table: string, schema?: string): CreateTableBuilder;

package/dist/builder/ddl/create-table.mjs

@@ -0,0 +1,186 @@
+
+export class ForeignKeyBuilder {
+	_onDelete;
+	_onUpdate;
+	constructor(onDelete, onUpdate) {
+		this._onDelete = onDelete;
+		this._onUpdate = onUpdate;
+	}
+	onDelete(action) {
+		return new ForeignKeyBuilder(action, this._onUpdate);
+	}
+	onUpdate(action) {
+		return new ForeignKeyBuilder(this._onDelete, action);
+	}
+	
+	_getOnDelete() {
+		return this._onDelete;
+	}
+	
+	_getOnUpdate() {
+		return this._onUpdate;
+	}
+}
+
+export class ColumnDefBuilder {
+	node;
+	constructor(name, dataType) {
+		this.node = {
+			type: "column_definition",
+			name,
+			dataType
+		};
+	}
+	clone(patch) {
+		const builder = new ColumnDefBuilder(this.node.name, this.node.dataType);
+		builder.node = {
+			...this.node,
+			...patch
+		};
+		return builder;
+	}
+	notNull() {
+		return this.clone({ notNull: true });
+	}
+	defaultTo(value) {
+		return this.clone({ defaultTo: value });
+	}
+	primaryKey() {
+		return this.clone({ primaryKey: true });
+	}
+	unique() {
+		return this.clone({ unique: true });
+	}
+	check(expr) {
+		return this.clone({ check: expr });
+	}
+	autoIncrement() {
+		return this.clone({ autoIncrement: true });
+	}
+	references(table, column) {
+		return this.clone({ references: {
+			table,
+			column,
+			onDelete: this.node.references?.onDelete,
+			onUpdate: this.node.references?.onUpdate
+		} });
+	}
+	onDelete(action) {
+		return this.clone({ references: this.node.references ? {
+			...this.node.references,
+			onDelete: action
+		} : undefined });
+	}
+	onUpdate(action) {
+		return this.clone({ references: this.node.references ? {
+			...this.node.references,
+			onUpdate: action
+		} : undefined });
+	}
+	generatedAlwaysAs(expr) {
+		return this.clone({ generatedAs: {
+			expression: expr,
+			stored: this.node.generatedAs?.stored
+		} });
+	}
+	stored() {
+		return this.clone({ generatedAs: this.node.generatedAs ? {
+			...this.node.generatedAs,
+			stored: true
+		} : undefined });
+	}
+	
+	_build() {
+		return { ...this.node };
+	}
+}
+
+export class CreateTableBuilder {
+	node;
+	constructor(table, schema) {
+		const tableRef = {
+			type: "table_ref",
+			name: table,
+			schema
+		};
+		this.node = {
+			type: "create_table",
+			table: tableRef,
+			columns: [],
+			constraints: []
+		};
+	}
+	cloneWith(patch) {
+		const builder = Object.create(CreateTableBuilder.prototype);
+		builder.node = {
+			...this.node,
+			...patch
+		};
+		return builder;
+	}
+	ifNotExists() {
+		return this.cloneWith({ ifNotExists: true });
+	}
+	temporary() {
+		return this.cloneWith({ temporary: true });
+	}
+	addColumn(name, dataType, build) {
+		let colBuilder = new ColumnDefBuilder(name, dataType);
+		if (build) {
+			colBuilder = build(colBuilder);
+		}
+		return this.cloneWith({ columns: [...this.node.columns, colBuilder._build()] });
+	}
+	addPrimaryKeyConstraint(name, columns) {
+		const constraint = {
+			type: "pk_constraint",
+			name,
+			columns
+		};
+		return this.cloneWith({ constraints: [...this.node.constraints, constraint] });
+	}
+	addUniqueConstraint(name, columns) {
+		const constraint = {
+			type: "unique_constraint",
+			name,
+			columns
+		};
+		return this.cloneWith({ constraints: [...this.node.constraints, constraint] });
+	}
+	addCheckConstraint(name, expression) {
+		const constraint = {
+			type: "check_constraint",
+			name,
+			expression
+		};
+		return this.cloneWith({ constraints: [...this.node.constraints, constraint] });
+	}
+	addForeignKeyConstraint(name, columns, refTable, refColumns, build) {
+		let fkBuilder = new ForeignKeyBuilder();
+		if (build) {
+			fkBuilder = build(fkBuilder);
+		}
+		const constraint = {
+			type: "fk_constraint",
+			name,
+			columns,
+			references: {
+				table: refTable,
+				columns: refColumns,
+				onDelete: fkBuilder._getOnDelete(),
+				onUpdate: fkBuilder._getOnUpdate()
+			}
+		};
+		return this.cloneWith({ constraints: [...this.node.constraints, constraint] });
+	}
+	asSelect(query) {
+		return this.cloneWith({ asSelect: query });
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+
+export function createTable(table, schema) {
+	return new CreateTableBuilder(table, schema);
+}

package/dist/builder/ddl/create-view.d.mts

@@ -0,0 +1,15 @@
+import type { CreateViewNode } from "../../ast/ddl-nodes.mjs";
+import type { SelectNode } from "../../ast/nodes.mjs";
+export declare class CreateViewBuilder {
+	private readonly node;
+	constructor(name: string, schema?: string);
+	constructor(node: CreateViewNode);
+	orReplace(): CreateViewBuilder;
+	temporary(): CreateViewBuilder;
+	materialized(): CreateViewBuilder;
+	ifNotExists(): CreateViewBuilder;
+	columns(...cols: string[]): CreateViewBuilder;
+	asSelect(query: SelectNode): CreateViewBuilder;
+	build(): CreateViewNode;
+}
+export declare function createView(name: string, schema?: string): CreateViewBuilder;

package/dist/builder/ddl/create-view.mjs

@@ -0,0 +1,57 @@
+export class CreateViewBuilder {
+	node;
+	constructor(nameOrNode, schema) {
+		if (typeof nameOrNode === "string") {
+			this.node = {
+				type: "create_view",
+				name: nameOrNode,
+				schema,
+				asSelect: undefined
+			};
+		} else {
+			this.node = nameOrNode;
+		}
+	}
+	orReplace() {
+		return new CreateViewBuilder({
+			...this.node,
+			orReplace: true
+		});
+	}
+	temporary() {
+		return new CreateViewBuilder({
+			...this.node,
+			temporary: true
+		});
+	}
+	materialized() {
+		return new CreateViewBuilder({
+			...this.node,
+			materialized: true
+		});
+	}
+	ifNotExists() {
+		return new CreateViewBuilder({
+			...this.node,
+			ifNotExists: true
+		});
+	}
+	columns(...cols) {
+		return new CreateViewBuilder({
+			...this.node,
+			columns: [...this.node.columns ?? [], ...cols]
+		});
+	}
+	asSelect(query) {
+		return new CreateViewBuilder({
+			...this.node,
+			asSelect: query
+		});
+	}
+	build() {
+		return { ...this.node };
+	}
+}
+export function createView(name, schema) {
+	return new CreateViewBuilder(name, schema);
+}