@apisr/drizzle-model 2.0.1 → 2.0.3

package/src/model/query/operations.ts

@@ -17,59 +17,59 @@ export type EscapedValue<T> =
 
 type OpValue<T> = T | SQL | EscapedValue<T>;
 
-export type ColumnOpsBase<T> = {
+export interface ColumnOpsBase<T> {
 	eq?: OpValue<T>;
 	equal?: OpValue<T>;
-	not?: OpValue<T>;
 	in?: OpValue<T>[];
-	nin?: OpValue<T>[];
 	isNull?: boolean;
-};
+	nin?: OpValue<T>[];
+	not?: OpValue<T>;
+}
 
-export type NumberOps = {
+export interface NumberOps {
+	between?: [OpValue<number>, OpValue<number>];
 	gt?: OpValue<number>;
 	gte?: OpValue<number>;
 	lt?: OpValue<number>;
 	lte?: OpValue<number>;
-	between?: [OpValue<number>, OpValue<number>];
 	notBetween?: [OpValue<number>, OpValue<number>];
-};
+}
 
-export type StringOps = {
-	like?: OpValue<string>;
-	ilike?: OpValue<string>;
-	startsWith?: OpValue<string>;
-	endsWith?: OpValue<string>;
+export interface StringOps {
 	contains?: OpValue<string>;
-	regex?: OpValue<string>;
-	notRegex?: OpValue<string>;
+	endsWith?: OpValue<string>;
+	ilike?: OpValue<string>;
 	length?: NumberOps;
-};
+	like?: OpValue<string>;
+	notRegex?: OpValue<string>;
+	regex?: OpValue<string>;
+	startsWith?: OpValue<string>;
+}
 
-export type BoolOps = {
-	isTrue?: boolean;
+export interface BoolOps {
 	isFalse?: boolean;
-};
+	isTrue?: boolean;
+}
 
-export type DateOps = {
-	before?: OpValue<Date | string>;
+export interface DateOps {
 	after?: OpValue<Date | string>;
-	on?: OpValue<Date | string>;
-	notOn?: OpValue<Date | string>;
+	before?: OpValue<Date | string>;
 	between?: [OpValue<Date | string>, OpValue<Date | string>];
-};
+	notOn?: OpValue<Date | string>;
+	on?: OpValue<Date | string>;
+}
 
-export type JsonOps<T> = {
+export interface JsonOps<T> {
 	has?: T;
-	hasAny?: T[];
 	hasAll?: T[];
+	hasAny?: T[];
 	len?: NumberOps;
-};
+}
 
-export type LogicalOps<TColumn extends Column> = {
-	or?: ColumnValue<TColumn>[];
+export interface LogicalOps<TColumn extends Column> {
 	and?: ColumnValue<TColumn>[];
-};
+	or?: ColumnValue<TColumn>[];
+}
 
 export type TypeOps<T> = T extends number
 	? NumberOps
@@ -103,29 +103,40 @@ export type ColumnValue<
  * - Drizzle ORM operators should be used directly
  * - complex types (e.g. Date, objects, custom classes) need safe handling
  *
- * There are two supported forms:
+ * There are three supported forms:
  *
  * 1) Implicit equality (default behavior):
  * ```ts
  * where({ name: esc("Alex") })
  * ```
- * Compiles to:
- * ```ts
- * {
- *  eq: "Alex"
- * }
- * // In drizzle: eq(column, "Alex")
- * ```
  *
  * 2) Explicit operator (Drizzle-style):
  * ```ts
  * where({ age: esc(gte, 18) })
  * ```
- * Compiles to:
+ *
+ * 3) Chainable operator methods (recommended):
  * ```ts
- * gte(column, 18)
+ * where({ name: esc.like("%Alex%") })
+ * where({ age: esc.gte(18) })
+ * where({ status: esc.in(["active", "pending"]) })
+ * where({ price: esc.between(10, 100) })
  * ```
  *
+ * Available chainable methods:
+ * - `esc.eq(value)` — equality
+ * - `esc.not(value)` — inequality
+ * - `esc.gt(value)` — greater than
+ * - `esc.gte(value)` — greater than or equal
+ * - `esc.lt(value)` — less than
+ * - `esc.lte(value)` — less than or equal
+ * - `esc.like(pattern)` — SQL LIKE pattern matching
+ * - `esc.ilike(pattern)` — case-insensitive LIKE
+ * - `esc.in(values)` — value in array
+ * - `esc.nin(values)` — value not in array
+ * - `esc.between(min, max)` — value between range
+ * - `esc.notBetween(min, max)` — value not between range
+ *
  * The column is injected later during query compilation.
  * `esc` does NOT execute the operator immediately.
  *
@@ -169,3 +180,30 @@ export function esc<T>(arg1: any, arg2?: any): EscapedValue<T> {
 		equal: arg1,
 	};
 }
+
+// Chainable operator methods - return DSL objects
+esc.eq = <T>(value: T) => ({ eq: value });
+
+esc.not = <T>(value: T) => ({ not: value });
+
+esc.gt = <T>(value: T) => ({ gt: value });
+
+esc.gte = <T>(value: T) => ({ gte: value });
+
+esc.lt = <T>(value: T) => ({ lt: value });
+
+esc.lte = <T>(value: T) => ({ lte: value });
+
+esc.like = (pattern: string) => ({ like: pattern });
+
+esc.ilike = (pattern: string) => ({ ilike: pattern });
+
+esc.in = <T>(values: T[]) => ({ in: values });
+
+esc.nin = <T>(values: T[]) => ({ nin: values });
+
+esc.between = <T>(min: T, max: T) => ({ between: [min, max] as [T, T] });
+
+esc.notBetween = <T>(min: T, max: T) => ({
+	notBetween: [min, max] as [T, T],
+});

package/tests/base/esc-chainable.test.ts

@@ -0,0 +1,159 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { model } from "tests/base";
+import { esc } from "@/model";
+
+const userModel = model("user", {});
+
+function uid(): string {
+	return `${Date.now()}-${Math.random()}`;
+}
+
+describe("esc chainable methods", () => {
+	let testUserId: number;
+
+	beforeAll(async () => {
+		const user = await userModel
+			.insert({
+				name: "Esc Test User",
+				email: `${uid()}@esc.com`,
+				age: 25,
+			})
+			.returnFirst();
+		testUserId = user.id;
+
+		await userModel.insert({
+			name: "Alice",
+			email: `${uid()}@esc.com`,
+			age: 30,
+		});
+
+		await userModel.insert({
+			name: "Bob",
+			email: `${uid()}@esc.com`,
+			age: 20,
+		});
+	});
+
+	test("esc.eq() - equality", async () => {
+		const users = await userModel.where({ id: esc.eq(testUserId) }).findMany();
+
+		expect(users).toBeArray();
+		expect(users.length).toBe(1);
+		expect(users[0]?.id).toBe(testUserId);
+	});
+
+	test("esc.not() - inequality", async () => {
+		const users = await userModel
+			.where({ id: esc.not(testUserId) })
+			.findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.id).not.toBe(testUserId);
+		}
+	});
+
+	test("esc.gt() - greater than", async () => {
+		const users = await userModel.where({ age: esc.gt(25) }).findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.age).toBeGreaterThan(25);
+		}
+	});
+
+	test("esc.gte() - greater than or equal", async () => {
+		const users = await userModel.where({ age: esc.gte(25) }).findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.age).toBeGreaterThanOrEqual(25);
+		}
+	});
+
+	test("esc.lt() - less than", async () => {
+		const users = await userModel.where({ age: esc.lt(25) }).findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.age).toBeLessThan(25);
+		}
+	});
+
+	test("esc.lte() - less than or equal", async () => {
+		const users = await userModel.where({ age: esc.lte(25) }).findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.age).toBeLessThanOrEqual(25);
+		}
+	});
+
+	test("esc.like() - pattern matching", async () => {
+		const users = await userModel.where({ name: esc.like("Esc%") }).findMany();
+
+		expect(users).toBeArray();
+		expect(users.length).toBeGreaterThan(0);
+		for (const user of users) {
+			expect(user.name.startsWith("Esc")).toBe(true);
+		}
+	});
+
+	test("esc.ilike() - case-insensitive pattern matching", async () => {
+		const users = await userModel
+			.where({ name: esc.ilike("%alice%") })
+			.findMany();
+
+		expect(users).toBeArray();
+		expect(users.length).toBeGreaterThan(0);
+		for (const user of users) {
+			expect(user.name.toLowerCase()).toContain("alice");
+		}
+	});
+
+	test("esc.in() - value in array", async () => {
+		const users = await userModel
+			.where({ name: esc.in(["Alice", "Bob"]) })
+			.findMany();
+
+		expect(users).toBeArray();
+		expect(users.length).toBeGreaterThan(0);
+		for (const user of users) {
+			expect(["Alice", "Bob"]).toContain(user.name);
+		}
+	});
+
+	test("esc.nin() - value not in array", async () => {
+		const users = await userModel
+			.where({ name: esc.nin(["Alice", "Bob"]) })
+			.findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(["Alice", "Bob"]).not.toContain(user.name);
+		}
+	});
+
+	test("esc.between() - value in range", async () => {
+		const users = await userModel
+			.where({ age: esc.between(20, 30) })
+			.findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.age).toBeGreaterThanOrEqual(20);
+			expect(user.age).toBeLessThanOrEqual(30);
+		}
+	});
+
+	test("esc.notBetween() - value outside range", async () => {
+		const users = await userModel
+			.where({ age: esc.notBetween(21, 29) })
+			.findMany();
+
+		expect(users).toBeArray();
+		for (const user of users) {
+			expect(user.age < 21 || user.age > 29).toBe(true);
+		}
+	});
+});

package/tests/snippets/x-2.ts

@@ -0,0 +1,30 @@
+import { esc, modelBuilder } from "src/model";
+import { db } from "../db";
+import { relations } from "../relations";
+import * as schema from "../schema";
+
+const model = modelBuilder({
+	schema,
+	db,
+	relations,
+	dialect: "PostgreSQL",
+});
+
+// create model
+const userModel = model("user", {});
+
+// #1 syntax
+await userModel
+	.where({
+		name: {
+			like: "A%",
+		},
+	})
+	.findFirst();
+
+// #2 syntax
+await userModel
+	.where({
+		name: esc.like("A%"),
+	})
+	.findFirst();

package/dist/model/core/joins.mjs

@@ -1,184 +0,0 @@
-import { and, eq } from "drizzle-orm";
-
-//#region src/model/core/joins.ts
-function isDrizzleColumn(value) {
-	return !!value && typeof value === "object" && typeof value.getSQL === "function";
-}
-function getPrimaryKeyField(table) {
-	for (const [k, v] of Object.entries(table)) {
-		if (!isDrizzleColumn(v)) continue;
-		if (v.primary === true) return k;
-		if (v.config?.primaryKey === true) return k;
-	}
-	if ("id" in table) return "id";
-	return Object.keys(table).find((k) => isDrizzleColumn(table[k])) ?? "id";
-}
-function isAllNullRow(obj) {
-	if (!obj || typeof obj !== "object") return true;
-	for (const v of Object.values(obj)) if (v !== null && v !== void 0) return false;
-	return true;
-}
-async function aliasTable(table, aliasName, dialect) {
-	if (dialect === "PostgreSQL") {
-		const mod = await import("drizzle-orm/pg-core");
-		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
-	}
-	if (dialect === "MySQL") {
-		const mod = await import("drizzle-orm/mysql-core");
-		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
-	}
-	if (dialect === "SQLite") {
-		const mod = await import("drizzle-orm/sqlite-core");
-		if (typeof mod.alias === "function") return mod.alias(table, aliasName);
-	}
-	return table;
-}
-function buildJoinOn(node) {
-	const parts = node.sourceColumns.map((src, i) => {
-		const tgt = node.targetColumns[i];
-		const tgtKey = Object.entries(node.targetTable).find(([, v]) => v === tgt)?.[0];
-		return eq(tgtKey ? node.targetAliasTable[tgtKey] : tgt, src);
-	});
-	return parts.length === 1 ? parts[0] : and(...parts);
-}
-function buildSelectMapForTable(table) {
-	const out = {};
-	for (const [k, v] of Object.entries(table)) if (isDrizzleColumn(v)) out[k] = v;
-	return out;
-}
-async function executeWithJoins(args) {
-	const { db, schema, relations, baseTableName, baseTable, dialect, whereSql, withValue, limitOne } = args;
-	const usedAliasKeys = /* @__PURE__ */ new Set();
-	const buildNode = async (parent, currentTableName, currentTable, key, value, path) => {
-		const relMeta = relations[currentTableName]?.relations?.[key];
-		if (!relMeta) throw new Error(`Unknown relation '${key}' on table '${currentTableName}'.`);
-		const targetTableName = relMeta.targetTableName;
-		const targetTable = schema[targetTableName];
-		const aliasKeyBase = [...path, key].join("__");
-		let aliasKey = aliasKeyBase;
-		let idx = 1;
-		while (usedAliasKeys.has(aliasKey)) aliasKey = `${aliasKeyBase}_${idx++}`;
-		usedAliasKeys.add(aliasKey);
-		const needsAlias = targetTableName === currentTableName || usedAliasKeys.has(`table:${targetTableName}`);
-		usedAliasKeys.add(`table:${targetTableName}`);
-		const targetAliasTable = needsAlias ? await aliasTable(targetTable, aliasKey, dialect) : targetTable;
-		const node = {
-			path: [...path, key],
-			key,
-			relationType: relMeta.relationType,
-			sourceTableName: currentTableName,
-			targetTableName,
-			sourceTable: currentTable,
-			targetTable,
-			targetAliasTable,
-			aliasKey,
-			sourceColumns: relMeta.sourceColumns ?? [],
-			targetColumns: relMeta.targetColumns ?? [],
-			pkField: getPrimaryKeyField(targetAliasTable),
-			parent,
-			children: []
-		};
-		if (value && typeof value === "object" && value !== true) for (const [childKey, childVal] of Object.entries(value)) {
-			if (childVal !== true && (typeof childVal !== "object" || childVal == null)) continue;
-			const child = await buildNode(node, targetTableName, targetAliasTable, childKey, childVal, [...path, key]);
-			node.children.push(child);
-		}
-		return node;
-	};
-	const root = {
-		path: [],
-		key: "$root",
-		relationType: "one",
-		sourceTableName: baseTableName,
-		targetTableName: baseTableName,
-		sourceTable: baseTable,
-		targetTable: baseTable,
-		targetAliasTable: baseTable,
-		aliasKey: "$base",
-		sourceColumns: [],
-		targetColumns: [],
-		pkField: getPrimaryKeyField(baseTable),
-		children: []
-	};
-	for (const [key, value] of Object.entries(withValue)) {
-		if (value !== true && (typeof value !== "object" || value == null)) continue;
-		const child = await buildNode(void 0, baseTableName, baseTable, key, value, []);
-		root.children.push(child);
-	}
-	const nodes = [];
-	const walk = (n) => {
-		for (const c of n.children) {
-			nodes.push(c);
-			walk(c);
-		}
-	};
-	walk(root);
-	const selectMap = { base: buildSelectMapForTable(baseTable) };
-	for (const n of nodes) selectMap[n.aliasKey] = buildSelectMapForTable(n.targetAliasTable);
-	let q = db.select(selectMap).from(baseTable);
-	if (whereSql) q = q.where(whereSql);
-	for (const n of nodes) {
-		const on = buildJoinOn(n);
-		q = q.leftJoin(n.targetAliasTable, on);
-	}
-	if (limitOne) q = q.limit(1);
-	const rows = await q;
-	const basePk = root.pkField;
-	const baseMap = /* @__PURE__ */ new Map();
-	const ensureManyContainer = (obj, key) => {
-		if (!Array.isArray(obj[key])) obj[key] = [];
-	};
-	const ensureOneContainer = (obj, key) => {
-		if (!(key in obj)) obj[key] = null;
-	};
-	const manyIndexByPath = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const baseRow = row.base;
-		const baseId = baseRow[basePk];
-		if (baseId === void 0) continue;
-		const baseObj = (() => {
-			const existing = baseMap.get(baseId);
-			if (existing) return existing;
-			const created = { ...baseRow };
-			baseMap.set(baseId, created);
-			return created;
-		})();
-		for (const n of nodes) {
-			const data = row[n.aliasKey];
-			const relPath = n.path.join(".");
-			const parentPath = n.parent ? n.parent.path.join(".") : "";
-			let parentObj = baseObj;
-			if (parentPath) {
-				const parentIndex = manyIndexByPath.get(parentPath);
-				if (parentIndex && parentIndex.size) parentObj = Array.from(parentIndex.values()).at(-1);
-				else {
-					const parentKey = n.parent?.key;
-					parentObj = parentKey ? baseObj[parentKey] ?? baseObj : baseObj;
-				}
-			}
-			if (isAllNullRow(data)) {
-				if (n.relationType === "one") ensureOneContainer(parentObj, n.key);
-				else ensureManyContainer(parentObj, n.key);
-				continue;
-			}
-			const pk = data[n.pkField];
-			if (n.relationType === "one") parentObj[n.key] = { ...data };
-			else {
-				ensureManyContainer(parentObj, n.key);
-				const indexKey = relPath;
-				if (!manyIndexByPath.has(indexKey)) manyIndexByPath.set(indexKey, /* @__PURE__ */ new Map());
-				const idxMap = manyIndexByPath.get(indexKey);
-				if (!idxMap.has(pk)) {
-					const obj = { ...data };
-					idxMap.set(pk, obj);
-					parentObj[n.key].push(obj);
-				}
-			}
-		}
-	}
-	const out = Array.from(baseMap.values());
-	return limitOne ? out[0] : out;
-}
-
-//#endregion
-export { executeWithJoins };

package/dist/model/core/projection.mjs

@@ -1,28 +0,0 @@
-//#region src/model/core/projection.ts
-function isDrizzleColumn(value) {
-	return !!value && typeof value === "object" && typeof value.getSQL === "function";
-}
-function getTableColumnsMap(table) {
-	const out = {};
-	for (const [key, value] of Object.entries(table)) if (isDrizzleColumn(value)) out[key] = value;
-	return out;
-}
-function buildSelectProjection(table, select, exclude) {
-	const all = getTableColumnsMap(table);
-	if (select && typeof select === "object") {
-		const picked = {};
-		for (const [key, value] of Object.entries(select)) if (value === true && key in all) picked[key] = all[key];
-		if (Object.keys(picked).length) return { selectMap: picked };
-		return { selectMap: all };
-	}
-	if (exclude && typeof exclude === "object") {
-		const omitted = { ...all };
-		for (const [key, value] of Object.entries(exclude)) if (value === true) delete omitted[key];
-		if (Object.keys(omitted).length) return { selectMap: omitted };
-		return { selectMap: all };
-	}
-	return { selectMap: all };
-}
-
-//#endregion
-export { buildSelectProjection };