sumak 0.0.7 → 0.0.9

package/dist/plugin/data-masking.mjs

@@ -0,0 +1,49 @@
+function maskEmail(value) {
+	if (typeof value !== "string") return value;
+	const atIndex = value.indexOf("@");
+	if (atIndex < 0) return value;
+	const local = value.slice(0, atIndex);
+	const domain = value.slice(atIndex);
+	const keep = local.slice(0, 2);
+	return `${keep}***${domain}`;
+}
+function maskPhone(value) {
+	if (typeof value !== "string") return value;
+	const last4 = value.slice(-4);
+	return `***${last4}`;
+}
+function maskPartial(value) {
+	if (typeof value !== "string") return value;
+	const keep = value.slice(0, 2);
+	return `${keep}***`;
+}
+const builtinMasks = {
+	email: maskEmail,
+	phone: maskPhone,
+	partial: maskPartial
+};
+
+export class DataMaskingPlugin {
+	name = "data-masking";
+	rules;
+	constructor(config) {
+		this.rules = new Map();
+		for (const rule of config.rules) {
+			const fn = typeof rule.mask === "string" ? builtinMasks[rule.mask] : rule.mask;
+			if (fn) {
+				this.rules.set(rule.column, fn);
+			}
+		}
+	}
+	transformResult(rows) {
+		return rows.map((row) => {
+			const masked = { ...row };
+			for (const [column, fn] of this.rules) {
+				if (column in masked) {
+					masked[column] = fn(masked[column]);
+				}
+			}
+			return masked;
+		});
+	}
+}

package/dist/plugin/multi-tenant.d.mts

@@ -0,0 +1,37 @@
+import type { ASTNode } from "../ast/nodes.mjs";
+import type { SumakPlugin } from "./types.mjs";
+/**
+* Plugin that auto-injects tenant_id filtering on all queries for configured tables.
+*
+* - SELECT/UPDATE/DELETE: adds `WHERE tenant_id = ?` (ANDed with existing WHERE)
+* - INSERT: adds tenant_id column and value to each row
+*
+* `tenantId` accepts a value OR a function that returns the value per-query.
+* Use a function for per-request tenant resolution (JWT, session, etc.):
+*
+* ```ts
+* new MultiTenantPlugin({
+*   tables: ["users", "posts"],
+*   tenantId: () => getCurrentTenantId(),
+* })
+* ```
+*/
+export declare class MultiTenantPlugin implements SumakPlugin {
+	readonly name = "multi-tenant";
+	private tables;
+	private column;
+	private getTenantId;
+	constructor(config: {
+		tables: string[];
+		column?: string;
+		tenantId: unknown | (() => unknown);
+	});
+	transformNode(node: ASTNode): ASTNode;
+	private isTargetTable;
+	private tenantCondition;
+	private addCondition;
+	private transformSelect;
+	private transformUpdate;
+	private transformDelete;
+	private transformInsert;
+}

package/dist/plugin/multi-tenant.mjs

@@ -0,0 +1,66 @@
+import { and, col, eq, param } from "../ast/expression.mjs";
+
+export class MultiTenantPlugin {
+	name = "multi-tenant";
+	tables;
+	column;
+	getTenantId;
+	constructor(config) {
+		this.tables = new Set(config.tables);
+		this.column = config.column ?? "tenant_id";
+		this.getTenantId = typeof config.tenantId === "function" ? config.tenantId : () => config.tenantId;
+	}
+	transformNode(node) {
+		switch (node.type) {
+			case "select": return this.transformSelect(node);
+			case "update": return this.transformUpdate(node);
+			case "delete": return this.transformDelete(node);
+			case "insert": return this.transformInsert(node);
+			default: return node;
+		}
+	}
+	isTargetTable(tableName) {
+		return this.tables.has(tableName);
+	}
+	tenantCondition() {
+		return eq(col(this.column), param(0, this.getTenantId()));
+	}
+	addCondition(existing) {
+		const condition = this.tenantCondition();
+		return existing ? and(existing, condition) : condition;
+	}
+	transformSelect(node) {
+		if (!node.from || node.from.type !== "table_ref" || !this.isTargetTable(node.from.name)) {
+			return node;
+		}
+		return {
+			...node,
+			where: this.addCondition(node.where)
+		};
+	}
+	transformUpdate(node) {
+		if (!this.isTargetTable(node.table.name)) return node;
+		return {
+			...node,
+			where: this.addCondition(node.where)
+		};
+	}
+	transformDelete(node) {
+		if (!this.isTargetTable(node.table.name)) return node;
+		return {
+			...node,
+			where: this.addCondition(node.where)
+		};
+	}
+	transformInsert(node) {
+		if (!this.isTargetTable(node.table.name)) return node;
+		const tenantId = this.getTenantId();
+		const columns = [...node.columns, this.column];
+		const values = node.values.map((row) => [...row, param(0, tenantId)]);
+		return {
+			...node,
+			columns,
+			values
+		};
+	}
+}

package/dist/plugin/optimistic-lock.d.mts

@@ -0,0 +1,38 @@
+import type { ASTNode } from "../ast/nodes.mjs";
+import type { SumakPlugin } from "./types.mjs";
+/**
+* Plugin that implements optimistic locking for configured tables.
+*
+* On UPDATE for configured tables:
+* 1. Adds `WHERE version = :currentVersion` (ANDed with existing WHERE)
+* 2. Adds `SET version = version + 1` to the SET clause
+*
+* `currentVersion` accepts a value OR a function that returns the value per-query.
+* Use a function when the version varies per row/request:
+*
+* ```ts
+* let rowVersion = 3
+* const plugin = new OptimisticLockPlugin({
+*   tables: ["users"],
+*   currentVersion: () => rowVersion,
+* })
+*
+* // Before each update, set rowVersion to the row's current version
+* rowVersion = fetchedRow.version
+* db.update("users").set({ name: "Bob" }).where(...).toSQL()
+* // UPDATE ... SET "version" = "version" + 1 WHERE ... AND "version" = $N
+* ```
+*/
+export declare class OptimisticLockPlugin implements SumakPlugin {
+	readonly name = "optimistic-lock";
+	private tables;
+	private column;
+	private getVersion;
+	constructor(config: {
+		tables: string[];
+		column?: string;
+		currentVersion: number | (() => number);
+	});
+	transformNode(node: ASTNode): ASTNode;
+	private transformUpdate;
+}

package/dist/plugin/optimistic-lock.mjs

@@ -0,0 +1,35 @@
+import { and, binOp, col, eq, param } from "../ast/expression.mjs";
+
+export class OptimisticLockPlugin {
+	name = "optimistic-lock";
+	tables;
+	column;
+	getVersion;
+	constructor(config) {
+		this.tables = new Set(config.tables);
+		this.column = config.column ?? "version";
+		this.getVersion = typeof config.currentVersion === "function" ? config.currentVersion : () => config.currentVersion;
+	}
+	transformNode(node) {
+		if (node.type !== "update") return node;
+		return this.transformUpdate(node);
+	}
+	transformUpdate(node) {
+		if (!this.tables.has(node.table.name)) return node;
+		const versionCondition = eq(col(this.column), param(0, this.getVersion()));
+		const where = node.where ? and(node.where, versionCondition) : versionCondition;
+		const versionIncrement = binOp("+", col(this.column), {
+			type: "literal",
+			value: 1
+		});
+		const set = [...node.set, {
+			column: this.column,
+			value: versionIncrement
+		}];
+		return {
+			...node,
+			set,
+			where
+		};
+	}
+}

package/dist/plugin/query-limit.d.mts

@@ -0,0 +1,20 @@
+import type { ASTNode } from "../ast/nodes.mjs";
+import type { SumakPlugin } from "./types.mjs";
+/**
+* Plugin that auto-injects a LIMIT on SELECT queries that don't already have one.
+*
+* ```ts
+* const plugin = new QueryLimitPlugin({ maxRows: 500 })
+* // SELECT * FROM "users"
+* // → SELECT * FROM "users" LIMIT 500
+* ```
+*/
+export declare class QueryLimitPlugin implements SumakPlugin {
+	readonly name = "query-limit";
+	private maxRows;
+	constructor(config?: {
+		maxRows?: number;
+	});
+	transformNode(node: ASTNode): ASTNode;
+	private transformSelect;
+}

package/dist/plugin/query-limit.mjs

@@ -0,0 +1,23 @@
+
+export class QueryLimitPlugin {
+	name = "query-limit";
+	maxRows;
+	constructor(config) {
+		this.maxRows = config?.maxRows ?? 1e3;
+	}
+	transformNode(node) {
+		if (node.type !== "select") return node;
+		return this.transformSelect(node);
+	}
+	transformSelect(node) {
+		if (node.limit) return node;
+		const limit = {
+			type: "literal",
+			value: this.maxRows
+		};
+		return {
+			...node,
+			limit
+		};
+	}
+}

package/dist/plugin/soft-delete.d.mts

@@ -1,21 +1,30 @@
 import type { ASTNode } from "../ast/nodes.mjs";
 import type { SumakPlugin } from "./types.mjs";
 /**
-* Plugin that automatically adds `WHERE deleted_at IS NULL` to
-* SELECT, UPDATE, and DELETE queries for configured tables.
+* Plugin that automatically handles soft deletes for configured tables.
+*
+* In "convert" mode (default):
+* - SELECT/UPDATE: adds `WHERE deleted_at IS NULL`
+* - DELETE: converts to `UPDATE SET deleted_at = NOW() WHERE ... AND deleted_at IS NULL`
+*
+* In "filter" mode:
+* - SELECT/UPDATE/DELETE: adds `WHERE deleted_at IS NULL`
 *
 * ```ts
-* const plugin = new SoftDeletePlugin({ tables: ["users", "posts"] });
-* // SELECT * FROM "users" → SELECT * FROM "users" WHERE "deleted_at" IS NULL
+* const plugin = new SoftDeletePlugin({ tables: ["users", "posts"] })
+* // DELETE FROM "users" WHERE id = 1
+* // → UPDATE "users" SET "deleted_at" = NOW() WHERE id = 1 AND "deleted_at" IS NULL
 * ```
 */
 export declare class SoftDeletePlugin implements SumakPlugin {
 	readonly name = "soft-delete";
 	private tables;
 	private column;
+	private mode;
 	constructor(config: {
 		tables: string[];
 		column?: string;
+		mode?: "filter" | "convert";
 	});
 	transformNode(node: ASTNode): ASTNode;
 	private isTargetTable;

package/dist/plugin/soft-delete.mjs

@@ -1,12 +1,14 @@
-import { and, col, isNull } from "../ast/expression.mjs";
+import { and, col, fn, isNull } from "../ast/expression.mjs";
 
 export class SoftDeletePlugin {
 	name = "soft-delete";
 	tables;
 	column;
+	mode;
 	constructor(config) {
 		this.tables = new Set(config.tables);
 		this.column = config.column ?? "deleted_at";
+		this.mode = config.mode ?? "convert";
 	}
 	transformNode(node) {
 		switch (node.type) {
@@ -44,9 +46,24 @@ export class SoftDeletePlugin {
 	}
 	transformDelete(node) {
 		if (!this.isTargetTable(node.table.name)) return node;
-		return {
-			...node,
-			where: this.addCondition(node.where)
+		if (this.mode === "filter") {
+			return {
+				...node,
+				where: this.addCondition(node.where)
+			};
+		}
+		const updateNode = {
+			type: "update",
+			table: node.table,
+			set: [{
+				column: this.column,
+				value: fn("NOW", [])
+			}],
+			where: this.addCondition(node.where),
+			returning: node.returning,
+			joins: node.joins,
+			ctes: node.ctes
 		};
+		return updateNode;
 	}
 }

package/dist/sumak.d.mts

@@ -78,6 +78,12 @@ export declare class Sumak<DB> {
 	selectFromSubquery<Alias extends string>(subquery: {
 		build(): import("./ast/nodes.ts").SelectNode;
 	}, alias: Alias): TypedSelectBuilder<DB, keyof DB & string, Record<string, unknown>>;
+	/**
+	* SELECT COUNT(*) FROM table — convenience shorthand.
+	*/
+	selectCount<T extends keyof DB & string>(table: T): TypedSelectBuilder<DB, T, {
+		count: number;
+	}>;
 	insertInto<T extends keyof DB & string>(table: T): TypedInsertBuilder<DB, T>;
 	update<T extends keyof DB & string>(table: T): TypedUpdateBuilder<DB, T>;
 	deleteFrom<T extends keyof DB & string>(table: T): TypedDeleteBuilder<DB, T>;

package/dist/sumak.mjs

@@ -35,7 +35,7 @@ export class Sumak {
 		return this._hooks.hook(name, handler);
 	}
 	selectFrom(table, alias) {
-		return new TypedSelectBuilder(new SelectBuilder().from(table, alias), table);
+		return new TypedSelectBuilder(new SelectBuilder().from(table, alias), table, this._dialect.createPrinter(), (node) => this.compile(node));
 	}
 	
 	selectFromSubquery(subquery, alias) {
@@ -46,14 +46,34 @@ export class Sumak {
 		};
 		return new TypedSelectBuilder(new SelectBuilder().from(sub), alias);
 	}
+	
+	selectCount(table) {
+		const star = { type: "star" };
+		const countFn = {
+			type: "function_call",
+			name: "COUNT",
+			args: [star],
+			alias: "count"
+		};
+		return new TypedSelectBuilder(new SelectBuilder().columns(countFn).from(table), table, this._dialect.createPrinter(), (node) => this.compile(node));
+	}
 	insertInto(table) {
-		return new TypedInsertBuilder(table);
+		const b = new TypedInsertBuilder(table);
+		b._printer = this._dialect.createPrinter();
+		b._compile = (node) => this.compile(node);
+		return b;
 	}
 	update(table) {
-		return new TypedUpdateBuilder(table);
+		const b = new TypedUpdateBuilder(table);
+		b._printer = this._dialect.createPrinter();
+		b._compile = (node) => this.compile(node);
+		return b;
 	}
 	deleteFrom(table) {
-		return new TypedDeleteBuilder(table);
+		const b = new TypedDeleteBuilder(table);
+		b._printer = this._dialect.createPrinter();
+		b._compile = (node) => this.compile(node);
+		return b;
 	}
 	
 	mergeInto(target, source, sourceAlias, on) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sumak",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Type-safe SQL query builder with powerful SQL printers. Zero dependencies, tree-shakeable. Pure TypeScript.",
   "keywords": [
     "database",