@apisr/drizzle-model 2.0.3 → 2.0.4

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change log
 
+## 2.0.4 | 02-03-2026
+- Fix custom methods execution error
+- Add custom methods tests
+
 ## 2.0.3 | 02-03-2026
 - I forgot to rebuild package in `2.0.2 to 2.0.0`, damn
 

package/dist/core/runtime.mjs

@@ -111,8 +111,8 @@ var ModelRuntime = class ModelRuntime {
 				...this.config.options,
 				...nextOptions,
 				methods: {
-					...nextOptions.methods ?? {},
-					...this.config.options.methods ?? {}
+					...this.config.options.methods ?? {},
+					...nextOptions.methods ?? {}
 				},
 				format: nextOptions.format ?? this.config.options.format
 			}

package/dist/model/builder.mjs

@@ -1,36 +1,62 @@
 import { ModelRuntime } from "../core/runtime.mjs";
 
 //#region src/model/builder.ts
+/**
+* Wraps a {@link ModelRuntime} instance into a plain target object that:
+*
+* 1. Exposes all runtime prototype methods, intercepting any that return a
+*    `ModelRuntime` so the result is re-wrapped (preserving custom methods).
+* 2. Defines the `$model`, `$modelName`, and `$format` identity getters.
+* 3. Attaches user-defined custom methods from `options.methods` via
+*    `runtime.attachMethods`, binding each to the new `target`.
+*
+* This must be called every time a new `ModelRuntime` is produced (e.g. by
+* `.where()`, `.extend()`, `.db()`) so that custom methods are never lost.
+*/
+function buildTarget(runtime) {
+	const target = {};
+	for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(runtime))) {
+		if (key === "constructor") continue;
+		const value = runtime[key];
+		if (typeof value === "function") target[key] = (...args) => {
+			const result = value.apply(runtime, args);
+			if (result instanceof ModelRuntime) return buildTarget(result);
+			return result;
+		};
+	}
+	Object.defineProperty(target, "$model", {
+		get: () => runtime.$model,
+		enumerable: true
+	});
+	Object.defineProperty(target, "$modelName", {
+		get: () => runtime.$modelName,
+		enumerable: true
+	});
+	Object.defineProperty(target, "$format", {
+		get: () => runtime.$format,
+		enumerable: true
+	});
+	Object.defineProperty(target, "$where", {
+		get: () => runtime.$where,
+		enumerable: true
+	});
+	Object.defineProperty(target, "$tableName", {
+		get: () => runtime.$tableName,
+		enumerable: true
+	});
+	runtime.attachMethods(target);
+	return target;
+}
 function modelBuilder({ db, relations, schema, dialect }) {
 	return (table, options) => {
-		const runtime = new ModelRuntime({
+		return buildTarget(new ModelRuntime({
 			db,
 			relations,
 			schema,
 			tableName: table,
 			dialect,
 			options: options ?? {}
-		});
-		const target = {};
-		for (const key of Object.getOwnPropertyNames(Object.getPrototypeOf(runtime))) {
-			if (key === "constructor") continue;
-			const value = runtime[key];
-			if (typeof value === "function") target[key] = value.bind(runtime);
-		}
-		Object.defineProperty(target, "$model", {
-			get: () => runtime.$model,
-			enumerable: true
-		});
-		Object.defineProperty(target, "$modelName", {
-			get: () => runtime.$modelName,
-			enumerable: true
-		});
-		Object.defineProperty(target, "$format", {
-			get: () => runtime.$format,
-			enumerable: true
-		});
-		runtime.attachMethods(target);
-		return target;
+		}));
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apisr/drizzle-model",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "private": false,
   "scripts": {
     "lint": "eslint . --max-warnings 0",

package/src/core/runtime.ts

@@ -177,8 +177,8 @@ export class ModelRuntime {
 				...this.config.options,
 				...nextOptions,
 				methods: {
-					...(nextOptions.methods ?? {}),
 					...(this.config.options.methods ?? {}),
+					...(nextOptions.methods ?? {}),
 				},
 				format: nextOptions.format ?? this.config.options.format,
 			} as ModelOptions<never, never, never, never>,

package/src/model/builder.ts

@@ -5,6 +5,78 @@ import type { ModelDialect } from "./dialect.ts";
 import type { Model } from "./model.ts";
 import type { ModelOptions } from "./options.ts";
 
+type AnyRecord = Record<string, unknown>;
+
+/**
+ * Wraps a {@link ModelRuntime} instance into a plain target object that:
+ *
+ * 1. Exposes all runtime prototype methods, intercepting any that return a
+ *    `ModelRuntime` so the result is re-wrapped (preserving custom methods).
+ * 2. Defines the `$model`, `$modelName`, and `$format` identity getters.
+ * 3. Attaches user-defined custom methods from `options.methods` via
+ *    `runtime.attachMethods`, binding each to the new `target`.
+ *
+ * This must be called every time a new `ModelRuntime` is produced (e.g. by
+ * `.where()`, `.extend()`, `.db()`) so that custom methods are never lost.
+ */
+function buildTarget(runtime: ModelRuntime): AnyRecord {
+	const target: AnyRecord = {};
+
+	for (const key of Object.getOwnPropertyNames(
+		Object.getPrototypeOf(runtime)
+	)) {
+		if (key === "constructor") {
+			continue;
+		}
+
+		const value = (runtime as unknown as AnyRecord)[key];
+
+		if (typeof value === "function") {
+			target[key] = (...args: unknown[]) => {
+				const result = (value as (...args: unknown[]) => unknown).apply(
+					runtime,
+					args
+				);
+
+				// Lifecycle methods (where, extend, db) return a new ModelRuntime.
+				// Re-wrap it so custom methods are re-attached on the fresh target.
+				if (result instanceof ModelRuntime) {
+					return buildTarget(result);
+				}
+
+				return result;
+			};
+		}
+	}
+
+	Object.defineProperty(target, "$model", {
+		get: () => runtime.$model,
+		enumerable: true,
+	});
+	Object.defineProperty(target, "$modelName", {
+		get: () => runtime.$modelName,
+		enumerable: true,
+	});
+	Object.defineProperty(target, "$format", {
+		get: () => runtime.$format,
+		enumerable: true,
+	});
+	Object.defineProperty(target, "$where", {
+		get: () => runtime.$where,
+		enumerable: true,
+	});
+	Object.defineProperty(target, "$tableName", {
+		get: () => runtime.$tableName,
+		enumerable: true,
+	});
+
+	// Attach user-defined methods, binding each to this target so that `this`
+	// inside a custom method refers to the model-like object (with all methods).
+	runtime.attachMethods(target);
+
+	return target;
+}
+
 export function modelBuilder<
 	TFullSchema extends Record<string, unknown> = Record<string, never>,
 	TRelations extends AnyRelations = EmptyRelations,
@@ -44,36 +116,7 @@ export function modelBuilder<
 			options: (options ?? {}) as any,
 		});
 
-		const target: Record<string, unknown> = {};
-
-		for (const key of Object.getOwnPropertyNames(
-			Object.getPrototypeOf(runtime)
-		)) {
-			if (key === "constructor") {
-				continue;
-			}
-			const value = (runtime as unknown as Record<string, unknown>)[key];
-			if (typeof value === "function") {
-				target[key] = value.bind(runtime);
-			}
-		}
-
-		Object.defineProperty(target, "$model", {
-			get: () => runtime.$model,
-			enumerable: true,
-		});
-		Object.defineProperty(target, "$modelName", {
-			get: () => runtime.$modelName,
-			enumerable: true,
-		});
-		Object.defineProperty(target, "$format", {
-			get: () => runtime.$format,
-			enumerable: true,
-		});
-
-		runtime.attachMethods(target);
-
-		return target as unknown as Model<
+		return buildTarget(runtime) as unknown as Model<
 			ModelConfig<TRelations, TRelations[TTableName], TDialect, TOptions>
 		>;
 	};

package/tests/base/custom-methods.test.ts

@@ -0,0 +1,335 @@
+import { describe, expect, test } from "bun:test";
+import { model } from "tests/base";
+import { db } from "tests/db";
+import { esc } from "@/model";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function uid(): string {
+	return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+
+// ─── Models ───────────────────────────────────────────────────────────────────
+
+/**
+ * A user model that defines several custom methods.
+ * These must remain accessible after every lifecycle call
+ * (.where, .extend, .db).
+ */
+const userModel = model("user", {});
+
+const serviceQueries = userModel.extend({
+	methods: {
+		findByName(name: string) {
+			return serviceQueries.where({ name: esc(name) }).findFirst();
+		},
+		findAllVerified() {
+			return serviceQueries.where({ isVerified: esc(true) }).findMany();
+		},
+		findByMinAge(minAge: number) {
+			return serviceQueries.where({ age: { gte: esc(minAge) } }).findMany();
+		},
+	},
+});
+
+const postsModel = model("userPosts", {});
+
+const postQueries = postsModel.extend({
+	methods: {
+		findByTitle(title: string) {
+			return postQueries.where({ title: esc(title) }).findFirst();
+		},
+		findFeatured() {
+			return postQueries.where({ featured: esc(true) }).findMany();
+		},
+	},
+});
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("custom methods", () => {
+	// -------------------------------------------------------------------------
+	// Presence — methods must be callable on the initial model object
+	// -------------------------------------------------------------------------
+
+	describe("presence on initial model", () => {
+		test("all declared methods are functions on the model", () => {
+			expect(typeof serviceQueries.findByName).toBe("function");
+			expect(typeof serviceQueries.findAllVerified).toBe("function");
+			expect(typeof serviceQueries.findByMinAge).toBe("function");
+		});
+
+		test("multiple models keep their own method sets independent", () => {
+			expect(typeof serviceQueries.findByName).toBe("function");
+			expect(typeof postQueries.findByTitle).toBe("function");
+			// cross-model — methods must NOT bleed across models
+			expect(
+				(serviceQueries as { findByTitle?: unknown }).findByTitle
+			).toBeUndefined();
+			expect(
+				(postQueries as { findByName?: unknown }).findByName
+			).toBeUndefined();
+		});
+	});
+
+	// -------------------------------------------------------------------------
+	// Survival through .where() — THE PRIMARY BUG
+	// Custom methods must survive every `.where()` call.
+	// -------------------------------------------------------------------------
+
+	describe("survival after .where()", () => {
+		test("custom methods are present on the result of .where()", () => {
+			const scoped = serviceQueries.where({ age: { gte: esc(0) } });
+			expect(typeof scoped.findByName).toBe("function");
+			expect(typeof scoped.findAllVerified).toBe("function");
+			expect(typeof scoped.findByMinAge).toBe("function");
+		});
+
+		test("custom methods are present after chained .where() calls", () => {
+			const scoped = serviceQueries
+				.where({ age: { gte: esc(0) } })
+				.where({ isVerified: esc(false) });
+			expect(typeof scoped.findByName).toBe("function");
+		});
+
+		test("base methods are still present after .where()", () => {
+			const scoped = serviceQueries.where({ age: { gte: esc(0) } });
+			expect(typeof scoped.findFirst).toBe("function");
+			expect(typeof scoped.findMany).toBe("function");
+			expect(typeof scoped.insert).toBe("function");
+			expect(typeof scoped.update).toBe("function");
+			expect(typeof scoped.delete).toBe("function");
+		});
+	});
+
+	// -------------------------------------------------------------------------
+	// Survival through .extend()
+	// -------------------------------------------------------------------------
+
+	describe("survival after .extend()", () => {
+		test("original custom methods survive .extend()", () => {
+			const extended = serviceQueries.extend({});
+			expect(typeof extended.findByName).toBe("function");
+			expect(typeof extended.findAllVerified).toBe("function");
+		});
+
+		test("new methods added via .extend() are accessible", () => {
+			const extended = serviceQueries.extend({
+				methods: {
+					findAdults() {
+						return extended.where({ age: { gte: esc(18) } }).findMany();
+					},
+				},
+			});
+			expect(typeof extended.findAdults).toBe("function");
+		});
+
+		test("parent custom methods survive on an extended model", () => {
+			const extended = serviceQueries.extend({
+				methods: {
+					findAdults() {
+						return extended.where({ age: { gte: esc(18) } }).findMany();
+					},
+				},
+			});
+			// Parent methods must still be present on the child
+			expect(typeof extended.findByName).toBe("function");
+			expect(typeof extended.findAllVerified).toBe("function");
+			// New method must be present too
+			expect(typeof extended.findAdults).toBe("function");
+		});
+
+		test("child method overrides parent method of the same name", () => {
+			const SENTINEL = Symbol("override-sentinel");
+			const extended = serviceQueries.extend({
+				methods: {
+					findByName(_name: string) {
+						return SENTINEL;
+					},
+				},
+			});
+			// The extended model's findByName must shadow the parent's
+			expect(extended.findByName("ignored")).toBe(SENTINEL);
+		});
+
+		test("custom methods survive .where() on an extended model", () => {
+			const extended = serviceQueries.extend({
+				methods: {
+					findAdults() {
+						return extended.where({ age: { gte: esc(18) } }).findMany();
+					},
+				},
+			});
+			const scoped = extended.where({ isVerified: esc(true) });
+			expect(typeof scoped.findByName).toBe("function");
+			expect(typeof scoped.findAdults).toBe("function");
+		});
+	});
+
+	// -------------------------------------------------------------------------
+	// Survival through .db()
+	// -------------------------------------------------------------------------
+
+	describe("survival after .db()", () => {
+		test("custom methods are present after .db() rebind", () => {
+			const rebound = serviceQueries.db(db);
+			expect(typeof rebound.findByName).toBe("function");
+			expect(typeof rebound.findAllVerified).toBe("function");
+			expect(typeof rebound.findByMinAge).toBe("function");
+		});
+
+		test("base methods are still present after .db() rebind", () => {
+			const rebound = serviceQueries.db(db);
+			expect(typeof rebound.findFirst).toBe("function");
+			expect(typeof rebound.findMany).toBe("function");
+		});
+
+		test("custom methods survive .where() after .db() rebind", () => {
+			const rebound = serviceQueries.db(db).where({ age: { gte: esc(0) } });
+			expect(typeof rebound.findByName).toBe("function");
+		});
+	});
+
+	// -------------------------------------------------------------------------
+	// Functional correctness — custom methods actually return the right data
+	// -------------------------------------------------------------------------
+
+	describe("functional correctness", () => {
+		test("findByName returns a single user with matching name", async () => {
+			const uniqueName = `TestUser-${uid()}`;
+			const uniqueEmail = `${uid()}@custom-methods.test`;
+
+			await serviceQueries.insert({
+				name: uniqueName,
+				email: uniqueEmail,
+				age: 25,
+			});
+
+			const result = await serviceQueries.findByName(uniqueName);
+
+			expect(result).toBeDefined();
+			expect(result?.name).toBe(uniqueName);
+			expect(typeof result?.id).toBe("number");
+		});
+
+		test("findAllVerified returns only verified users", async () => {
+			const result = await serviceQueries.findAllVerified();
+
+			expect(Array.isArray(result)).toBe(true);
+			for (const user of result) {
+				expect(user.isVerified).toBe(true);
+			}
+		});
+
+		test("findByMinAge returns users at or above the age threshold", async () => {
+			const result = await serviceQueries.findByMinAge(18);
+
+			expect(Array.isArray(result)).toBe(true);
+			for (const user of result) {
+				expect(user.age).toBeGreaterThanOrEqual(18);
+			}
+		});
+
+		test("custom method result is consistent with equivalent base query", async () => {
+			const uniqueName = `Consistent-${uid()}`;
+			const uniqueEmail = `${uid()}@custom-methods.test`;
+
+			await serviceQueries.insert({
+				name: uniqueName,
+				email: uniqueEmail,
+				age: 30,
+			});
+
+			const viaCustom = await serviceQueries.findByName(uniqueName);
+			const viaBase = await serviceQueries
+				.where({ name: esc(uniqueName) })
+				.findFirst();
+
+			expect(viaCustom).toEqual(viaBase);
+		});
+
+		test("posts custom method findByTitle returns correct post", async () => {
+			const uniqueTitle = `PostTitle-${uid()}`;
+
+			await postQueries.insert({
+				title: uniqueTitle,
+				featured: false,
+				userId: 1,
+			});
+
+			const result = await postQueries.findByTitle(uniqueTitle);
+
+			expect(result).toBeDefined();
+			expect(result?.title).toBe(uniqueTitle);
+		});
+
+		test("posts custom method findFeatured returns only featured posts", async () => {
+			await postQueries.insert({
+				title: `Featured-${uid()}`,
+				featured: true,
+				userId: 1,
+			});
+
+			const result = await postQueries.findFeatured();
+
+			expect(Array.isArray(result)).toBe(true);
+			expect(result.length).toBeGreaterThan(0);
+			for (const post of result) {
+				expect(post.featured).toBe(true);
+			}
+		});
+
+		test("custom method is still functional after .where() (the bug scenario)", async () => {
+			const uniqueName = `BugCheck-${uid()}`;
+			const uniqueEmail = `${uid()}@custom-methods.test`;
+
+			await serviceQueries.insert({
+				name: uniqueName,
+				email: uniqueEmail,
+				age: 99,
+			});
+
+			const scopedModel = serviceQueries.where({ age: { gte: esc(0) } });
+			const result = await scopedModel.findByName(uniqueName);
+
+			expect(result).toBeDefined();
+			expect(result?.name).toBe(uniqueName);
+		});
+
+		test("custom method is still functional after .extend()", async () => {
+			const uniqueName = `ExtendBug-${uid()}`;
+			const uniqueEmail = `${uid()}@custom-methods.test`;
+
+			await serviceQueries.insert({
+				name: uniqueName,
+				email: uniqueEmail,
+				age: 22,
+			});
+
+			const extended = serviceQueries.extend({
+				format: (u) => ({ ...u, _extended: true }),
+			});
+			const result = await extended.findByName(uniqueName);
+
+			expect(result).toBeDefined();
+			expect(result?.name).toBe(uniqueName);
+		});
+
+		test("custom method is still functional after .db()", async () => {
+			const uniqueName = `DbBug-${uid()}`;
+			const uniqueEmail = `${uid()}@custom-methods.test`;
+
+			await serviceQueries.insert({
+				name: uniqueName,
+				email: uniqueEmail,
+				age: 33,
+			});
+
+			const rebound = serviceQueries.db(db);
+			const result = await rebound.findByName(uniqueName);
+
+			expect(result).toBeDefined();
+			expect(result?.name).toBe(uniqueName);
+		});
+	});
+});