@tylix/orm 0.6.0 → 1.0.0

package/src/model/traits.js

@@ -0,0 +1,61 @@
+// Traits: reusable model behaviour, as JavaScript mixins. A trait is a
+// function that takes a model class and returns a class extending it:
+//
+//   export const SoftLabels = (Base) => class extends Base {
+//     static async labelled(label) { return this.where('label', label).get() }
+//   }
+//
+//   class Post extends use(Model, Searchable({ fields: ['title', 'body'] }), SoftLabels) {
+//     static table = 'posts'
+//   }
+//
+// A trait can bring observer hooks too: `static observers = [...]` on the
+// class it returns runs alongside the model's own observers.
+
+export function use(Base, ...traits) {
+  return traits.reduce((Current, trait, i) => {
+    if (typeof trait !== 'function') {
+      throw new TypeError(`use(): trait ${i + 1} is not a function. Did you forget to call a trait factory, e.g. Searchable({ fields })?`)
+    }
+    const Next = trait(Current)
+    if (typeof Next !== 'function' || !(Next === Current || Object.prototype.isPrototypeOf.call(Current, Next))) {
+      throw new TypeError(`use(): trait ${i + 1} must return a class that extends the one it was given.`)
+    }
+    return Next
+  }, Base)
+}
+
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/
+
+// Adds Model.search(term) over the given columns:
+//   class Post extends use(Model, Searchable({ fields: ['title', 'body'] })) {}
+//   await Post.search('tylix')               // rows whose title or body contains it
+//   await Post.search('tylix', { limit: 10 })
+// Matching is case-insensitive (LIKE on every driver). It uses plain where()
+// queries, one per field, so it works on SQLite, MySQL, PostgreSQL and
+// MongoDB alike; for large tables use a full-text index instead.
+export function Searchable(options = {}) {
+  if (typeof options === 'function') {
+    throw new TypeError('Searchable is a trait factory: call it with options, e.g. use(Model, Searchable({ fields: ["title"] })).')
+  }
+  const { fields } = options
+  if (!Array.isArray(fields) || fields.length === 0 || !fields.every((f) => IDENTIFIER.test(f))) {
+    throw new TypeError('Searchable({ fields }) needs a list of column names, e.g. ["title", "body"].')
+  }
+  return (Base) =>
+    class extends Base {
+      static async search(term, { limit = 50 } = {}) {
+        const text = String(term ?? '').trim()
+        if (text === '') return []
+        const pattern = `%${text}%`
+        const found = new Map()
+        for (const field of fields) {
+          for (const row of await this.where(field, 'LIKE', pattern).get()) {
+            if (!found.has(row.id)) found.set(row.id, row)
+            if (found.size >= limit) return [...found.values()]
+          }
+        }
+        return [...found.values()]
+      }
+    }
+}

package/src/adapters/AdapterFactory.test.js

@@ -1,35 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { createAdapter } from "./AdapterFactory.js";
-import { SqliteAdapter } from "./SqliteAdapter.js";
-import { PostgresAdapter } from "./PostgresAdapter.js";
-import { MysqlAdapter } from "./MysqlAdapter.js";
-import { MongoAdapter } from "./MongoAdapter.js";
-
-test("creates a SqliteAdapter for driver: sqlite", () => {
-  const adapter = createAdapter({ driver: "sqlite", filename: "test.sqlite" });
-  assert.ok(adapter instanceof SqliteAdapter);
-  assert.equal(adapter.filename, "test.sqlite");
-});
-
-test("throws on unknown driver", () => {
-  assert.throws(
-    () => createAdapter({ driver: "oracle" }),
-    /Unknown database driver "oracle"/
-  );
-});
-
-test("creates a PostgresAdapter for driver: postgres", () => {
-  const adapter = createAdapter({ driver: "postgres", database: "test" });
-  assert.ok(adapter instanceof PostgresAdapter);
-});
-
-test("creates a MysqlAdapter for driver: mysql", () => {
-  const adapter = createAdapter({ driver: "mysql", database: "test" });
-  assert.ok(adapter instanceof MysqlAdapter);
-});
-
-test("creates a MongoAdapter for driver: mongodb", () => {
-  const adapter = createAdapter({ driver: "mongodb", database: "test" });
-  assert.ok(adapter instanceof MongoAdapter);
-});

package/src/adapters/MongoAdapter.test.js

@@ -1,52 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { parseQuery, MongoAdapter } from "./MongoAdapter.js";
-
-test("recognizes SELECT * FROM table", () => {
-  assert.deepEqual(parseQuery("SELECT * FROM posts"), { type: "findAll", table: "posts" });
-});
-
-test("recognizes SELECT * FROM table WHERE field = ?", () => {
-  assert.deepEqual(parseQuery("SELECT * FROM posts WHERE id = ?"), {
-    type: "findOne",
-    table: "posts",
-    field: "id",
-  });
-});
-
-test("recognizes INSERT INTO table (cols) VALUES (?...)", () => {
-  const result = parseQuery("INSERT INTO posts (title, body) VALUES (?, ?)");
-  assert.equal(result.type, "insert");
-  assert.equal(result.table, "posts");
-  assert.deepEqual(result.columns, ["title", "body"]);
-});
-
-test("recognizes UPDATE table SET col=?,col=? WHERE field = ?", () => {
-  const result = parseQuery("UPDATE posts SET title = ?, body = ? WHERE id = ?");
-  assert.equal(result.type, "update");
-  assert.deepEqual(result.columns, ["title", "body"]);
-  assert.equal(result.whereField, "id");
-});
-
-test("recognizes DELETE FROM table WHERE field = ?", () => {
-  assert.deepEqual(parseQuery("DELETE FROM posts WHERE id = ?"), {
-    type: "delete",
-    table: "posts",
-    field: "id",
-  });
-});
-
-test("recognizes CREATE TABLE IF NOT EXISTS as a no-op shape", () => {
-  const result = parseQuery("CREATE TABLE IF NOT EXISTS posts (id INT)");
-  assert.equal(result.type, "createTable");
-  assert.equal(result.table, "posts");
-});
-
-test("throws clearly on an unrecognized query shape", () => {
-  assert.throws(() => parseQuery("SELECT COUNT(*) FROM posts"), /does not recognize/);
-});
-
-test("ensureConnected throws before connect() is called", async () => {
-  const adapter = new MongoAdapter({ database: "test" });
-  await assert.rejects(() => adapter.all("SELECT * FROM posts"));
-});

package/src/adapters/MysqlAdapter.test.js

@@ -1,36 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { MysqlAdapter } from "./MysqlAdapter.js";
-
-test("columnType maps logical types to MySQL SQL types", () => {
-  const adapter = new MysqlAdapter({ database: "test" });
-  assert.equal(adapter.columnType("increments"), "INT AUTO_INCREMENT PRIMARY KEY");
-  assert.equal(adapter.columnType("string"), "VARCHAR(255)");
-  assert.equal(adapter.columnType("boolean"), "TINYINT(1)");
-  assert.equal(adapter.columnType("json"), "JSON");
-});
-
-test("columnType throws on unknown logical type", () => {
-  const adapter = new MysqlAdapter({ database: "test" });
-  assert.throws(() => adapter.columnType("nonsense"), /no mapping/);
-});
-
-test("ensureConnected throws before connect() is called", async () => {
-  const adapter = new MysqlAdapter({ database: "test" });
-  await assert.rejects(() => adapter.all("SELECT 1"));
-});
-
-test("toMysqlDateTime converts ISO 8601 strings to MySQL DATETIME format", async () => {
-  const { toMysqlDateTime } = await import("./MysqlAdapter.js");
-  assert.equal(
-    toMysqlDateTime("2026-07-14T03:35:14.083Z"),
-    "2026-07-14 03:35:14"
-  );
-});
-
-test("toMysqlDateTime leaves non-ISO-datetime values untouched", async () => {
-  const { toMysqlDateTime } = await import("./MysqlAdapter.js");
-  assert.equal(toMysqlDateTime("Hello Tylix"), "Hello Tylix");
-  assert.equal(toMysqlDateTime(42), 42);
-  assert.equal(toMysqlDateTime(true), true);
-});

package/src/adapters/PostgresAdapter.test.js

@@ -1,47 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { PostgresAdapter, toPositionalPlaceholders, ensureReturningId } from "./PostgresAdapter.js";
-
-test("toPositionalPlaceholders converts ? to $1, $2, $3...", () => {
-  const sql = "INSERT INTO posts (title, body) VALUES (?, ?)";
-  assert.equal(
-    toPositionalPlaceholders(sql),
-    "INSERT INTO posts (title, body) VALUES ($1, $2)"
-  );
-});
-
-test("toPositionalPlaceholders handles a single placeholder", () => {
-  assert.equal(toPositionalPlaceholders("SELECT * FROM posts WHERE id = ?"), "SELECT * FROM posts WHERE id = $1");
-});
-
-test("ensureReturningId appends RETURNING id to bare INSERT statements", () => {
-  const sql = "INSERT INTO posts (title) VALUES (?)";
-  assert.equal(ensureReturningId(sql), "INSERT INTO posts (title) VALUES (?) RETURNING id");
-});
-
-test("ensureReturningId does not duplicate an existing RETURNING clause", () => {
-  const sql = "INSERT INTO posts (title) VALUES (?) RETURNING id";
-  assert.equal(ensureReturningId(sql), sql);
-});
-
-test("ensureReturningId leaves non-INSERT statements untouched", () => {
-  const sql = "UPDATE posts SET title = ? WHERE id = ?";
-  assert.equal(ensureReturningId(sql), sql);
-});
-
-test("columnType maps logical types to Postgres SQL types", () => {
-  const adapter = new PostgresAdapter({ database: "test" });
-  assert.equal(adapter.columnType("increments"), "SERIAL PRIMARY KEY");
-  assert.equal(adapter.columnType("boolean"), "BOOLEAN");
-  assert.equal(adapter.columnType("json"), "JSONB");
-});
-
-test("columnType throws on unknown logical type", () => {
-  const adapter = new PostgresAdapter({ database: "test" });
-  assert.throws(() => adapter.columnType("nonsense"), /no mapping/);
-});
-
-test("ensureConnected throws before connect() is called", async () => {
-  const adapter = new PostgresAdapter({ database: "test" });
-  await assert.rejects(() => adapter.all("SELECT 1"));
-});

package/src/adapters/SqliteAdapter.test.js

@@ -1,39 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SqliteAdapter } from "./SqliteAdapter.js";
-
-test("connects, creates a table, inserts, and queries rows", async () => {
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "tylix-orm-test-"));
-  const dbFile = path.join(tmpDir, "test.sqlite");
-
-  const adapter = new SqliteAdapter({ filename: dbFile });
-  await adapter.connect();
-
-  await adapter.run(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT NOT NULL
-    )
-  `);
-
-  await adapter.run("INSERT INTO posts (title) VALUES (?)", ["Hello Tylix"]);
-  await adapter.run("INSERT INTO posts (title) VALUES (?)", ["Second Post"]);
-
-  const all = await adapter.all("SELECT * FROM posts");
-  assert.equal(all.length, 2);
-  assert.equal(all[0].title, "Hello Tylix");
-
-  const one = await adapter.get("SELECT * FROM posts WHERE id = ?", [1]);
-  assert.equal(one.title, "Hello Tylix");
-
-  await adapter.close();
-  await fs.rm(tmpDir, { recursive: true, force: true });
-});
-
-test("ensureConnected throws if used before connect()", async () => {
-  const adapter = new SqliteAdapter({ filename: ":memory:" });
-  await assert.rejects(() => adapter.all("SELECT 1"));
-});

package/src/adapters/query.test.js

@@ -1,60 +0,0 @@
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SqliteAdapter } from "./SqliteAdapter.js";
-
-let tmpDir;
-let adapter;
-
-beforeEach(async () => {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "tylix-query-test-"));
-  adapter = new SqliteAdapter({ filename: path.join(tmpDir, "test.sqlite") });
-  await adapter.connect();
-  await adapter.run(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT,
-      views INTEGER,
-      status TEXT
-    )
-  `);
-  await adapter.run("INSERT INTO posts (title, views, status) VALUES (?, ?, ?)", ["A", 50, "draft"]);
-  await adapter.run("INSERT INTO posts (title, views, status) VALUES (?, ?, ?)", ["B", 150, "published"]);
-  await adapter.run("INSERT INTO posts (title, views, status) VALUES (?, ?, ?)", ["C", 300, "published"]);
-});
-
-afterEach(async () => {
-  await adapter.close();
-  await fs.rm(tmpDir, { recursive: true, force: true });
-});
-
-test("query() with a where filter", async () => {
-  const rows = await adapter.query("posts", {
-    wheres: [{ field: "status", operator: "=", value: "published" }],
-  });
-  assert.equal(rows.length, 2);
-});
-
-test("query() with where + orderBy + limit combined", async () => {
-  const rows = await adapter.query("posts", {
-    wheres: [{ field: "status", operator: "=", value: "published" }],
-    orders: [{ field: "views", direction: "DESC" }],
-    limitValue: 1,
-  });
-  assert.equal(rows.length, 1);
-  assert.equal(rows[0].title, "C");
-});
-
-test("query() with a > comparison operator", async () => {
-  const rows = await adapter.query("posts", {
-    wheres: [{ field: "views", operator: ">", value: 100 }],
-  });
-  assert.equal(rows.length, 2);
-});
-
-test("query() with no descriptor returns all rows", async () => {
-  const rows = await adapter.query("posts", {});
-  assert.equal(rows.length, 3);
-});

package/src/model/Model.paginate.test.js

@@ -1,74 +0,0 @@
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SqliteAdapter } from "../adapters/SqliteAdapter.js";
-import { ConnectionManager } from "./ConnectionManager.js";
-import { Model } from "./Model.js";
-
-class Post extends Model {
-  static table = "posts";
-  static fillable = ["title"];
-}
-
-let tmpDir;
-let adapter;
-
-beforeEach(async () => {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "tylix-paginate-test-"));
-  adapter = new SqliteAdapter({ filename: path.join(tmpDir, "test.sqlite") });
-  await adapter.connect();
-  await adapter.run(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT,
-      created_at TEXT,
-      updated_at TEXT
-    )
-  `);
-  ConnectionManager.setAdapter(adapter);
-
-  for (let i = 1; i <= 25; i++) {
-    await Post.create({ title: `Post ${i}` });
-  }
-});
-
-afterEach(async () => {
-  await adapter.close();
-  await fs.rm(tmpDir, { recursive: true, force: true });
-  ConnectionManager.reset();
-});
-
-test("paginate() defaults to page 1, limit 20", async () => {
-  const result = await Post.paginate();
-  assert.equal(result.data.length, 20);
-  assert.equal(result.data[0].title, "Post 1");
-  assert.equal(result.meta.page, 1);
-  assert.equal(result.meta.limit, 20);
-  assert.equal(result.meta.total, 25);
-  assert.equal(result.meta.totalPages, 2);
-});
-
-test("paginate() returns the second page correctly", async () => {
-  const result = await Post.paginate({ page: 2, limit: 20 });
-  assert.equal(result.data.length, 5);
-  assert.equal(result.data[0].title, "Post 21");
-});
-
-test("paginate() respects a custom limit", async () => {
-  const result = await Post.paginate({ page: 1, limit: 10 });
-  assert.equal(result.data.length, 10);
-  assert.equal(result.meta.totalPages, 3);
-});
-
-test("paginate() clamps limit to a maximum of 100", async () => {
-  const result = await Post.paginate({ page: 1, limit: 9999 });
-  assert.equal(result.meta.limit, 100);
-});
-
-test("paginate() clamps page to a minimum of 1", async () => {
-  const result = await Post.paginate({ page: -5, limit: 20 });
-  assert.equal(result.meta.page, 1);
-  assert.equal(result.data[0].title, "Post 1");
-});

package/src/model/Model.relations.test.js

@@ -1,86 +0,0 @@
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SqliteAdapter } from "../adapters/SqliteAdapter.js";
-import { ConnectionManager } from "./ConnectionManager.js";
-import { Model } from "./Model.js";
-
-class Post extends Model {
-  static table = "posts";
-  static fillable = ["title"];
-}
-
-class Comment extends Model {
-  static table = "comments";
-  static fillable = ["content", "post_id"];
-}
-
-let tmpDir;
-let adapter;
-
-beforeEach(async () => {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "tylix-relations-test-"));
-  adapter = new SqliteAdapter({ filename: path.join(tmpDir, "test.sqlite") });
-  await adapter.connect();
-
-  await adapter.run(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT,
-      created_at TEXT,
-      updated_at TEXT
-    )
-  `);
-
-  await adapter.run(`
-    CREATE TABLE comments (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      content TEXT,
-      post_id INTEGER,
-      created_at TEXT,
-      updated_at TEXT
-    )
-  `);
-
-  ConnectionManager.setAdapter(adapter);
-});
-
-afterEach(async () => {
-  await adapter.close();
-  await fs.rm(tmpDir, { recursive: true, force: true });
-  ConnectionManager.reset();
-});
-
-test("belongsTo() loads the parent row via foreign key", async () => {
-  const post = await Post.create({ title: "Hello" });
-  const comment = await Comment.create({ content: "Nice post!", post_id: post.id });
-
-  const loadedPost = await Comment.belongsTo(comment, "post_id", Post);
-  assert.equal(loadedPost.title, "Hello");
-});
-
-test("belongsTo() returns null when foreign key is missing", async () => {
-  const orphan = { content: "no post", post_id: null };
-  const result = await Comment.belongsTo(orphan, "post_id", Post);
-  assert.equal(result, null);
-});
-
-test("hasMany() loads all child rows for a parent", async () => {
-  const post = await Post.create({ title: "Popular Post" });
-  await Comment.create({ content: "First!", post_id: post.id });
-  await Comment.create({ content: "Second!", post_id: post.id });
-  await Comment.create({ content: "Unrelated", post_id: 9999 });
-
-  const comments = await Post.hasMany(post, Comment, "post_id");
-  assert.equal(comments.length, 2);
-  assert.equal(comments[0].content, "First!");
-  assert.equal(comments[1].content, "Second!");
-});
-
-test("hasMany() returns an empty array when there are no children", async () => {
-  const post = await Post.create({ title: "Lonely Post" });
-  const comments = await Post.hasMany(post, Comment, "post_id");
-  assert.deepEqual(comments, []);
-});

package/src/model/Model.test.js

@@ -1,91 +0,0 @@
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SqliteAdapter } from "../adapters/SqliteAdapter.js";
-import { ConnectionManager } from "./ConnectionManager.js";
-import { Model } from "./Model.js";
-
-class Post extends Model {
-  static table = "posts";
-  static fillable = ["title", "body"];
-}
-
-let tmpDir;
-let adapter;
-
-beforeEach(async () => {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "tylix-model-test-"));
-  adapter = new SqliteAdapter({ filename: path.join(tmpDir, "test.sqlite") });
-  await adapter.connect();
-  await adapter.run(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT NOT NULL,
-      body TEXT,
-      created_at TEXT,
-      updated_at TEXT
-    )
-  `);
-  ConnectionManager.setAdapter(adapter);
-});
-
-afterEach(async () => {
-  await adapter.close();
-  await fs.rm(tmpDir, { recursive: true, force: true });
-  ConnectionManager.reset();
-});
-
-test("create() inserts a row and returns it", async () => {
-  const post = await Post.create({ title: "Hello Tylix", body: "First post" });
-  assert.equal(post.title, "Hello Tylix");
-  assert.equal(post.body, "First post");
-  assert.ok(post.id);
-});
-
-test("create() populates created_at and updated_at", async () => {
-  const post = await Post.create({ title: "Timestamped", body: "..." });
-  assert.ok(post.created_at, "created_at should be set");
-  assert.ok(post.updated_at, "updated_at should be set");
-  assert.ok(!Number.isNaN(Date.parse(post.created_at)), "created_at should be a valid date string");
-});
-
-test("all() returns every row", async () => {
-  await Post.create({ title: "One", body: "..." });
-  await Post.create({ title: "Two", body: "..." });
-  const posts = await Post.all();
-  assert.equal(posts.length, 2);
-});
-
-test("find() returns a single row by id", async () => {
-  const created = await Post.create({ title: "Findable", body: "..." });
-  const found = await Post.find(created.id);
-  assert.equal(found.title, "Findable");
-});
-
-test("update() modifies a row and returns the updated version", async () => {
-  const created = await Post.create({ title: "Original", body: "..." });
-  const updated = await Post.update(created.id, { title: "Updated" });
-  assert.equal(updated.title, "Updated");
-});
-
-test("update() bumps updated_at without changing created_at", async () => {
-  const created = await Post.create({ title: "Original", body: "..." });
-  await new Promise((resolve) => setTimeout(resolve, 10));
-  const updated = await Post.update(created.id, { title: "Changed" });
-
-  assert.equal(updated.created_at, created.created_at);
-  assert.notEqual(updated.updated_at, created.updated_at);
-});
-
-test("delete() removes a row", async () => {
-  const created = await Post.create({ title: "ToDelete", body: "..." });
-  await Post.delete(created.id);
-  const found = await Post.find(created.id);
-  assert.equal(found, null);
-});
-
-test("create() throws if no fillable fields are provided", async () => {
-  await assert.rejects(() => Post.create({ nonExistentField: "x" }));
-});

package/src/query/QueryBuilder.test.js

@@ -1,82 +0,0 @@
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SqliteAdapter } from "../adapters/SqliteAdapter.js";
-import { ConnectionManager } from "../model/ConnectionManager.js";
-import { Model } from "../model/Model.js";
-
-class Post extends Model {
-  static table = "posts";
-  static fillable = ["title", "views", "status"];
-}
-
-let tmpDir;
-let adapter;
-
-beforeEach(async () => {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "tylix-querybuilder-test-"));
-  adapter = new SqliteAdapter({ filename: path.join(tmpDir, "test.sqlite") });
-  await adapter.connect();
-  await adapter.run(`
-    CREATE TABLE posts (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT,
-      views INTEGER,
-      status TEXT,
-      created_at TEXT,
-      updated_at TEXT
-    )
-  `);
-  ConnectionManager.setAdapter(adapter);
-
-  await Post.create({ title: "Draft Post", views: 10, status: "draft" });
-  await Post.create({ title: "Popular Post", views: 500, status: "published" });
-  await Post.create({ title: "Medium Post", views: 150, status: "published" });
-});
-
-afterEach(async () => {
-  await adapter.close();
-  await fs.rm(tmpDir, { recursive: true, force: true });
-  ConnectionManager.reset();
-});
-
-test("Post.query() with where() filters correctly", async () => {
-  const results = await Post.query().where("status", "published").get();
-  assert.equal(results.length, 2);
-});
-
-test("where() with explicit operator", async () => {
-  const results = await Post.query().where("views", ">", 100).get();
-  assert.equal(results.length, 2);
-});
-
-test("orderBy() and limit() chain correctly", async () => {
-  const results = await Post.query()
-    .where("status", "published")
-    .orderBy("views", "DESC")
-    .limit(1)
-    .get();
-
-  assert.equal(results.length, 1);
-  assert.equal(results[0].title, "Popular Post");
-});
-
-test("first() returns a single row or null", async () => {
-  const found = await Post.query().where("status", "draft").first();
-  assert.equal(found.title, "Draft Post");
-
-  const notFound = await Post.query().where("status", "archived").first();
-  assert.equal(notFound, null);
-});
-
-test("count() returns the number of matching rows", async () => {
-  const count = await Post.query().where("status", "published").count();
-  assert.equal(count, 2);
-});
-
-test("query() with no where() returns all rows", async () => {
-  const results = await Post.query().get();
-  assert.equal(results.length, 3);
-});