@tylix/orm 0.5.1 → 0.7.0

package/src/query/buildSelectSql.js

@@ -1,4 +1,91 @@
-const SUPPORTED_OPERATORS = ["=", "!=", ">", "<", ">=", "<="];
+const COMPARISON_OPERATORS = ["=", "!=", "<>", ">", "<", ">=", "<="];
+const NULL_OPERATORS = ["IS NULL", "IS NOT NULL"];
+const LIST_OPERATORS = ["IN", "NOT IN"];
+
+// "like" and other lowercase spellings are accepted and normalized first.
+const SUPPORTED_OPERATORS = [
+  ...COMPARISON_OPERATORS,
+  "LIKE",
+  ...NULL_OPERATORS,
+  ...LIST_OPERATORS,
+];
+
+// What a LIKE condition is written as in SQL. MySQL and SQLite are already
+// case-insensitive for LIKE, so they keep "LIKE"; PostgreSQL is
+// case-sensitive, so its adapter asks for "ILIKE" to behave the same way.
+const LIKE_OPERATORS = ["LIKE", "ILIKE"];
+
+// Each value in an IN list is its own "?" placeholder, and every driver caps
+// the number of placeholders per statement.
+const MAX_LIST_VALUES = 1000;
+
+// Letters, digits and underscores only, with an optional "table.column" form.
+// Rejects spaces, quotes, semicolons, comments and anything else that could
+// change the shape of the query.
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+
+function assertIdentifier(name, kind) {
+  if (typeof name !== "string" || !IDENTIFIER.test(name)) {
+    throw new Error(`Invalid ${kind} name "${String(name)}".`);
+  }
+  return name;
+}
+
+function normalizeOperator(operator) {
+  return String(operator).trim().replace(/\s+/g, " ").toUpperCase();
+}
+
+// Builds one WHERE condition and pushes its values onto `params`.
+function buildCondition(w, likeOperator, params) {
+  const operator = normalizeOperator(w.operator);
+  if (!SUPPORTED_OPERATORS.includes(operator)) {
+    throw new Error(
+      `Unsupported where operator "${w.operator}". Supported: ${SUPPORTED_OPERATORS.join(", ")}`
+    );
+  }
+
+  const column = assertIdentifier(w.field, "column");
+
+  if (NULL_OPERATORS.includes(operator)) {
+    return `${column} ${operator}`;
+  }
+
+  if (LIST_OPERATORS.includes(operator)) {
+    const values = w.value;
+    if (!Array.isArray(values)) {
+      throw new Error(`Operator "${operator}" needs an array of values.`);
+    }
+    if (values.length > MAX_LIST_VALUES) {
+      throw new Error(
+        `Operator "${operator}" accepts at most ${MAX_LIST_VALUES} values, got ${values.length}.`
+      );
+    }
+    // NULL never matches inside IN, and a single NULL makes NOT IN match
+    // nothing at all, so reject it instead of returning surprising rows.
+    if (values.some((v) => v === null || v === undefined)) {
+      throw new Error(
+        `"${operator}" lists cannot contain null or undefined. Use whereNull() / whereNotNull() for null checks.`
+      );
+    }
+    // "IN ()" is invalid SQL. An empty IN matches nothing; an empty NOT IN
+    // excludes nothing.
+    if (values.length === 0) {
+      return operator === "IN" ? "1 = 0" : "1 = 1";
+    }
+    params.push(...values);
+    return `${column} ${operator} (${values.map(() => "?").join(", ")})`;
+  }
+
+  // "= NULL" and "!= NULL" are never true in SQL, so translate them.
+  if (w.value === null) {
+    if (operator === "=") return `${column} IS NULL`;
+    if (operator === "!=" || operator === "<>") return `${column} IS NOT NULL`;
+    throw new Error(`Operator "${operator}" cannot be used with null.`);
+  }
+
+  params.push(w.value);
+  return `${column} ${operator === "LIKE" ? likeOperator : operator} ?`;
+}
 
 /**
  * Translates a structured query descriptor into a "?"-placeholder SQL
@@ -8,29 +95,38 @@ const SUPPORTED_OPERATORS = ["=", "!=", ">", "<", ">=", "<="];
  * translation and datetime conversion correctly per driver, so this
  * only needs to speak the common "?" dialect.
  *
+ * Values are always passed as parameters. Table and column names cannot be
+ * parameters, so they are validated as plain identifiers instead.
+ *
  * limit/offset are inlined as validated integers rather than passed as
  * placeholders, since mysql2 does not reliably support placeholders in
  * LIMIT/OFFSET position (same reasoning as Model.paginate()).
+ *
+ * options.likeOperator: "LIKE" (default) or "ILIKE", used for LIKE conditions.
  */
-export function buildSelectSql(table, { wheres = [], orders = [], limitValue, offsetValue } = {}) {
+export function buildSelectSql(
+  table,
+  { wheres = [], orders = [], limitValue, offsetValue } = {},
+  { likeOperator = "LIKE" } = {}
+) {
+  if (!LIKE_OPERATORS.includes(likeOperator)) {
+    throw new Error(
+      `Unsupported likeOperator "${likeOperator}". Use: ${LIKE_OPERATORS.join(", ")}`
+    );
+  }
+
   const params = [];
-  let sql = `SELECT * FROM ${table}`;
+  let sql = `SELECT * FROM ${assertIdentifier(table, "table")}`;
 
   if (wheres.length > 0) {
-    const clauses = wheres.map((w) => {
-      if (!SUPPORTED_OPERATORS.includes(w.operator)) {
-        throw new Error(
-          `Unsupported where operator "${w.operator}". Supported: ${SUPPORTED_OPERATORS.join(", ")}`
-        );
-      }
-      params.push(w.value);
-      return `${w.field} ${w.operator} ?`;
-    });
+    const clauses = wheres.map((w) => buildCondition(w, likeOperator, params));
     sql += ` WHERE ${clauses.join(" AND ")}`;
   }
 
   if (orders.length > 0) {
-    const clauses = orders.map((o) => `${o.field} ${o.direction}`);
+    const clauses = orders.map(
+      (o) => `${assertIdentifier(o.field, "column")} ${o.direction}`
+    );
     sql += ` ORDER BY ${clauses.join(", ")}`;
   }
 
@@ -47,4 +143,4 @@ export function buildSelectSql(table, { wheres = [], orders = [], limitValue, of
   }
 
   return { sql, params };
-}
+}

package/src/query/types.d.ts

@@ -1,7 +1,21 @@
-// src/query/types.d.ts
+export type ComparisonOperator =
+  | '='
+  | '!='
+  | '<>'
+  | '>'
+  | '<'
+  | '>='
+  | '<='
+  | 'LIKE'
+  | 'like'
+
+export type ListOperator = 'IN' | 'NOT IN'
+
+export type NullOperator = 'IS NULL' | 'IS NOT NULL'
+
 export interface WhereClause {
   field: string
-  operator: '=' | '!=' | '>' | '<' | '>=' | '<='
+  operator: ComparisonOperator | ListOperator | NullOperator
   value: unknown
 }
 
@@ -15,4 +29,28 @@ export interface QueryDescriptor {
   orders: OrderClause[]
   limitValue?: number
   offsetValue?: number
+}
+
+export interface ColumnBuilder {
+  unique(): void;
+}
+
+export interface TableBuilder {
+  increments(name: string): ColumnBuilder;
+  string(name: string): ColumnBuilder;
+  text(name: string): ColumnBuilder;
+  boolean(name: string): ColumnBuilder;
+  integer(name: string): ColumnBuilder;
+  date(name: string): ColumnBuilder;
+  datetime(name: string): ColumnBuilder;
+  json(name: string): ColumnBuilder;
+  timestamps(): void;
+  // present only in alterTable's callback, absent from createTable's
+  dropColumn?(name: string): void;
+}
+
+export interface Schema {
+  createTable(tableName: string, callback: (table: TableBuilder) => void | Promise<void>): Promise<void>;
+  dropTable(tableName: string): Promise<void>;
+  alterTable(tableName: string, callback: (table: TableBuilder) => void | Promise<void>): Promise<void>;
 }

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, []);
-});