alepha 0.14.1 → 0.14.3

package/src/orm/__tests__/$repository-crud.spec.ts

@@ -0,0 +1,276 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { DbEntityNotFoundError } from "../errors/DbEntityNotFoundError.ts";
+import { $entity, $repository, pg } from "../index.ts";
+import type { InsertUserEntity } from "./fixtures/userEntitySchema.ts";
+
+class App {
+  users = $repository(
+    $entity({
+      name: "users",
+      schema: t.object({
+        id: pg.primaryKey(),
+        createdAt: pg.createdAt(),
+        updatedAt: pg.updatedAt(),
+        name: t.text(),
+        profile: t.object({
+          age: t.number(),
+        }),
+        role: pg.default(t.text(), "user"),
+      }),
+    }),
+  );
+}
+
+const testBasicCrud = async (alepha: Alepha) => {
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // ========================================
+  // CREATE OPERATIONS
+  // ========================================
+
+  // Test: create single entity
+  const createdUser = await app.users.create({
+    name: "Alice",
+    profile: { age: 30 },
+    role: "admin",
+  });
+
+  expect(createdUser.id).toBeDefined();
+  expect(createdUser.name).toBe("Alice");
+  expect(createdUser.profile?.age).toBe(30);
+  expect(createdUser.role).toBe("admin");
+
+  const aliceId = createdUser.id;
+
+  // Test: createMany
+  const manyUsers: InsertUserEntity[] = [
+    { name: "Bob", profile: { age: 25 }, role: "user" },
+    { name: "Charlie", profile: { age: 35 }, role: "admin" },
+    { name: "David", profile: { age: 28 }, role: "user" },
+    { name: "Eve", profile: { age: 32 }, role: "moderator" },
+  ];
+
+  const createdMany = await app.users.createMany(manyUsers);
+  expect(createdMany).toHaveLength(4);
+  expect(createdMany[0].name).toBe("Bob");
+  expect(createdMany[1].name).toBe("Charlie");
+  expect(createdMany[2].name).toBe("David");
+  expect(createdMany[3].name).toBe("Eve");
+
+  // Test: createMany with empty array
+  const emptyResult = await app.users.createMany([]);
+  expect(emptyResult).toHaveLength(0);
+
+  // ========================================
+  // FIND OPERATIONS
+  // ========================================
+
+  // Test: find all
+  const allUsers = await app.users.findMany();
+  expect(allUsers).toHaveLength(5);
+
+  // Test: find with where clause (exact match)
+  const adminUsers = await app.users.findMany({
+    where: { role: { eq: "admin" } },
+  });
+  expect(adminUsers).toHaveLength(2);
+  expect(adminUsers.every((u) => u.role === "admin")).toBe(true);
+
+  // Test: find with limit
+  const limitedUsers = await app.users.findMany({ limit: 2 });
+  expect(limitedUsers).toHaveLength(2);
+
+  // Test: find with offset
+  const offsetUsers = await app.users.findMany({ offset: 3 });
+  expect(offsetUsers).toHaveLength(2);
+
+  // Test: find with limit and offset
+  const paginatedUsers = await app.users.findMany({ limit: 2, offset: 1 });
+  expect(paginatedUsers).toHaveLength(2);
+
+  // Test: findOne
+  const foundAlice = await app.users.findOne({
+    where: { name: { eq: "Alice" } },
+  });
+  expect(foundAlice.id).toBe(aliceId);
+  expect(foundAlice.name).toBe("Alice");
+
+  // Test: findOne throws when not found
+  await expect(
+    app.users.findOne({ where: { name: { eq: "NonExistent" } } }),
+  ).rejects.toThrowError(DbEntityNotFoundError);
+
+  // Test: findById
+  const userById = await app.users.findById(aliceId);
+  expect(userById.id).toBe(aliceId);
+  expect(userById.name).toBe("Alice");
+
+  // Test: findById throws when not found
+  await expect(app.users.findById(999999)).rejects.toThrowError(
+    DbEntityNotFoundError,
+  );
+
+  // ========================================
+  // COUNT OPERATIONS
+  // ========================================
+
+  // Test: count all
+  const totalCount = await app.users.count();
+  expect(totalCount).toBe(5);
+
+  // Test: count with where clause
+  const adminCount = await app.users.count({ role: { eq: "admin" } });
+  expect(adminCount).toBe(2);
+
+  const userCount = await app.users.count({ role: { eq: "user" } });
+  expect(userCount).toBe(2);
+
+  const moderatorCount = await app.users.count({ role: { eq: "moderator" } });
+  expect(moderatorCount).toBe(1);
+
+  // ========================================
+  // UPDATE OPERATIONS
+  // ========================================
+
+  // Test: updateOne
+  const updatedAlice = await app.users.updateOne(
+    { id: { eq: aliceId } },
+    { name: "Alice Updated", role: "admin" }, // Keep role since defaults apply
+  );
+  expect(updatedAlice.id).toBe(aliceId);
+  expect(updatedAlice.name).toBe("Alice Updated");
+  expect(updatedAlice.role).toBe("admin");
+
+  // Test: updateOne throws when not found
+  await expect(
+    app.users.updateOne({ id: { eq: 999999 } }, { name: "Should Fail" }),
+  ).rejects.toThrowError(DbEntityNotFoundError);
+
+  // Test: updateById
+  const updatedByIdAlice = await app.users.updateById(aliceId, {
+    role: "superadmin",
+  });
+  expect(updatedByIdAlice.id).toBe(aliceId);
+  expect(updatedByIdAlice.role).toBe("superadmin");
+  expect(updatedByIdAlice.name).toBe("Alice Updated"); // Previous update persisted
+
+  // Verify update persisted
+  const verifyAlice = await app.users.findById(aliceId);
+  expect(verifyAlice.name).toBe("Alice Updated");
+  expect(verifyAlice.role).toBe("superadmin");
+
+  // Test: updateMany
+  const updatedUserIds = await app.users.updateMany(
+    { role: { eq: "user" } },
+    { role: "member" },
+  );
+  expect(updatedUserIds).toHaveLength(2);
+
+  // Verify updateMany worked
+  const members = await app.users.findMany({
+    where: { role: { eq: "member" } },
+  });
+  expect(members).toHaveLength(2);
+  expect(members.every((u) => u.role === "member")).toBe(true);
+
+  // Test: save
+  const userToSave = await app.users.findOne({
+    where: { name: { eq: "Charlie" } },
+  });
+  userToSave.name = "Charlie Saved";
+  userToSave.profile = { age: 36 };
+  await app.users.save(userToSave);
+
+  const savedUser = await app.users.findById(userToSave.id);
+  expect(savedUser.name).toBe("Charlie Saved");
+  expect(savedUser.profile?.age).toBe(36);
+
+  // ========================================
+  // DELETE OPERATIONS
+  // ========================================
+
+  // Test: deleteOne
+  const bob = await app.users.findOne({ where: { name: { eq: "Bob" } } });
+  const deletedOneIds = await app.users.deleteOne({ id: { eq: bob.id } });
+  expect(deletedOneIds).toHaveLength(1);
+  expect(deletedOneIds[0]).toBe(bob.id);
+
+  // Verify bob is deleted
+  const usersAfterDeleteOne = await app.users.findMany();
+  expect(usersAfterDeleteOne).toHaveLength(4);
+  expect(usersAfterDeleteOne.every((u) => u.name !== "Bob")).toBe(true);
+
+  // Test: deleteById
+  const eve = await app.users.findOne({ where: { name: { eq: "Eve" } } });
+  const deletedByIdResult = await app.users.deleteById(eve.id);
+  expect(deletedByIdResult).toHaveLength(1);
+  expect(deletedByIdResult[0]).toBe(eve.id);
+
+  // Test: deleteById throws when not found
+  await expect(app.users.deleteById(999999)).rejects.toThrowError(
+    DbEntityNotFoundError,
+  );
+
+  // Verify eve is deleted
+  const usersAfterDeleteById = await app.users.findMany();
+  expect(usersAfterDeleteById).toHaveLength(3);
+
+  // Test: destroy (delete by entity)
+  const david = await app.users.findOne({ where: { name: { eq: "David" } } });
+  const destroyedIds = await app.users.destroy(david);
+  expect(destroyedIds).toHaveLength(1);
+  expect(destroyedIds[0]).toBe(david.id);
+
+  // Verify david is deleted
+  const usersAfterDestroy = await app.users.findMany();
+  expect(usersAfterDestroy).toHaveLength(2);
+
+  // Test: deleteMany
+  const deletedManyIds = await app.users.deleteMany({
+    role: { eq: "superadmin" },
+  });
+  expect(deletedManyIds).toHaveLength(1);
+  expect(deletedManyIds[0]).toBe(aliceId);
+
+  // Verify only Charlie remains
+  const remainingUsers = await app.users.findMany();
+  expect(remainingUsers).toHaveLength(1);
+  expect(remainingUsers[0].name).toBe("Charlie Saved");
+
+  // Test: clear (delete all)
+  await app.users.createMany([
+    { name: "Test1", profile: { age: 20 }, role: "user" },
+    { name: "Test2", profile: { age: 21 }, role: "user" },
+    { name: "Test3", profile: { age: 22 }, role: "admin" },
+  ]);
+
+  const beforeClearCount = await app.users.count();
+  expect(beforeClearCount).toBe(4);
+
+  const clearedIds = await app.users.clear({ force: true });
+  expect(clearedIds).toHaveLength(4);
+
+  const afterClearCount = await app.users.count();
+  expect(afterClearCount).toBe(0);
+
+  const emptyFind = await app.users.findMany();
+  expect(emptyFind).toHaveLength(0);
+};
+
+describe("$repository - CRUD operations", () => {
+  it("should support basic CRUD operations (postgres)", async () => {
+    await testBasicCrud(Alepha.create());
+  });
+
+  it("should support basic CRUD operations (pglite)", async () => {
+    process.env.DATABASE_URL = "pglite://:memory:";
+    await testBasicCrud(Alepha.create());
+  });
+
+  it("should support basic CRUD operations (sqlite)", async () => {
+    process.env.DATABASE_URL = "sqlite://:memory:";
+    await testBasicCrud(Alepha.create());
+  });
+});

package/src/orm/__tests__/$repository-hooks.spec.ts

@@ -0,0 +1,325 @@
+import { $hook, Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $entity, $repository, pg } from "../index.ts";
+
+class HookTracker {
+  events: Array<{ name: string; data: any }> = [];
+
+  clear() {
+    this.events = [];
+  }
+
+  record(name: string, data: any) {
+    this.events.push({ name, data });
+  }
+
+  find(name: string) {
+    return this.events.filter((e) => e.name === name);
+  }
+
+  findLast(name: string) {
+    const events = this.find(name);
+    return events[events.length - 1];
+  }
+}
+
+class App {
+  tracker = new HookTracker();
+
+  users = $repository(
+    $entity({
+      name: "users",
+      schema: t.object({
+        id: pg.primaryKey(),
+        name: t.text(),
+        email: t.text(),
+      }),
+    }),
+  );
+
+  // Hook: Create Before
+  createBefore = $hook({
+    on: "repository:create:before",
+    handler: async ({ data, tableName }) => {
+      this.tracker.record("create:before", { tableName, data });
+    },
+  });
+
+  // Hook: Create After
+  createAfter = $hook({
+    on: "repository:create:after",
+    handler: async ({ data, entity, tableName }) => {
+      this.tracker.record("create:after", { tableName, data, entity });
+    },
+  });
+
+  // Hook: Read Before
+  readBefore = $hook({
+    on: "repository:read:before",
+    handler: async ({ query, tableName }) => {
+      this.tracker.record("read:before", { tableName, query });
+    },
+  });
+
+  // Hook: Read After
+  readAfter = $hook({
+    on: "repository:read:after",
+    handler: async ({ query, entities, tableName }) => {
+      this.tracker.record("read:after", { tableName, query, entities });
+    },
+  });
+
+  // Hook: Update Before
+  updateBefore = $hook({
+    on: "repository:update:before",
+    handler: async ({ where, data, tableName }) => {
+      this.tracker.record("update:before", { tableName, where, data });
+    },
+  });
+
+  // Hook: Update After
+  updateAfter = $hook({
+    on: "repository:update:after",
+    handler: async ({ where, data, entities, tableName }) => {
+      this.tracker.record("update:after", { tableName, where, data, entities });
+    },
+  });
+
+  // Hook: Delete Before
+  deleteBefore = $hook({
+    on: "repository:delete:before",
+    handler: async ({ where, tableName }) => {
+      this.tracker.record("delete:before", { tableName, where });
+    },
+  });
+
+  // Hook: Delete After
+  deleteAfter = $hook({
+    on: "repository:delete:after",
+    handler: async ({ where, ids, tableName }) => {
+      this.tracker.record("delete:after", { tableName, where, ids });
+    },
+  });
+}
+
+const testRepositoryHooks = async (alepha: Alepha) => {
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // ========================================
+  // CREATE HOOKS
+  // ========================================
+
+  // Test: create hook (single entity)
+  app.tracker.clear();
+  const user1 = await app.users.create({
+    name: "Alice",
+    email: "alice@example.com",
+  });
+
+  expect(app.tracker.find("create:before")).toHaveLength(1);
+  expect(app.tracker.find("create:after")).toHaveLength(1);
+
+  const createBeforeEvent = app.tracker.findLast("create:before");
+  expect(createBeforeEvent.data.tableName).toBe("users");
+  expect(createBeforeEvent.data.data.name).toBe("Alice");
+
+  const createAfterEvent = app.tracker.findLast("create:after");
+  expect(createAfterEvent.data.tableName).toBe("users");
+  expect(createAfterEvent.data.entity.id).toBe(user1.id);
+  expect(createAfterEvent.data.entity.name).toBe("Alice");
+
+  // Test: createMany hook
+  app.tracker.clear();
+  const users = await app.users.createMany([
+    { name: "Bob", email: "bob@example.com" },
+    { name: "Charlie", email: "charlie@example.com" },
+  ]);
+
+  expect(app.tracker.find("create:before")).toHaveLength(1);
+  expect(app.tracker.find("create:after")).toHaveLength(1);
+
+  const createManyBeforeEvent = app.tracker.findLast("create:before");
+  expect(createManyBeforeEvent.data.tableName).toBe("users");
+  expect(createManyBeforeEvent.data.data).toHaveLength(2);
+
+  const createManyAfterEvent = app.tracker.findLast("create:after");
+  expect(createManyAfterEvent.data.tableName).toBe("users");
+  expect(createManyAfterEvent.data.entity).toHaveLength(2);
+  expect(createManyAfterEvent.data.entity[0].name).toBe("Bob");
+  expect(createManyAfterEvent.data.entity[1].name).toBe("Charlie");
+
+  // ========================================
+  // READ HOOKS
+  // ========================================
+
+  // Test: find hook
+  app.tracker.clear();
+  const allUsers = await app.users.findMany();
+
+  expect(app.tracker.find("read:before")).toHaveLength(1);
+  expect(app.tracker.find("read:after")).toHaveLength(1);
+
+  const readBeforeEvent = app.tracker.findLast("read:before");
+  expect(readBeforeEvent.data.tableName).toBe("users");
+  expect(readBeforeEvent.data.query).toBeDefined();
+
+  const readAfterEvent = app.tracker.findLast("read:after");
+  expect(readAfterEvent.data.tableName).toBe("users");
+  expect(readAfterEvent.data.entities).toHaveLength(3);
+
+  // Test: findOne hook (uses find internally)
+  app.tracker.clear();
+  await app.users.findOne({ where: { name: { eq: "Alice" } } });
+
+  expect(app.tracker.find("read:before")).toHaveLength(1);
+  expect(app.tracker.find("read:after")).toHaveLength(1);
+
+  // Test: findById hook (uses find internally)
+  app.tracker.clear();
+  await app.users.findById(user1.id);
+
+  expect(app.tracker.find("read:before")).toHaveLength(1);
+  expect(app.tracker.find("read:after")).toHaveLength(1);
+
+  // Test: paginate hook (uses find internally)
+  app.tracker.clear();
+  await app.users.paginate({ page: 0, size: 10 });
+
+  // paginate calls find once
+  expect(app.tracker.find("read:before")).toHaveLength(1);
+  expect(app.tracker.find("read:after")).toHaveLength(1);
+
+  // ========================================
+  // UPDATE HOOKS
+  // ========================================
+
+  // Test: updateOne hook
+  app.tracker.clear();
+  await app.users.updateOne(
+    { id: { eq: user1.id } },
+    { name: "Alice Updated" },
+  );
+
+  expect(app.tracker.find("update:before")).toHaveLength(1);
+  expect(app.tracker.find("update:after")).toHaveLength(1);
+
+  const updateBeforeEvent = app.tracker.findLast("update:before");
+  expect(updateBeforeEvent.data.tableName).toBe("users");
+  expect(updateBeforeEvent.data.data.name).toBe("Alice Updated");
+
+  const updateAfterEvent = app.tracker.findLast("update:after");
+  expect(updateAfterEvent.data.tableName).toBe("users");
+  expect(updateAfterEvent.data.entities).toHaveLength(1);
+  expect(updateAfterEvent.data.entities[0].name).toBe("Alice Updated");
+
+  // Test: updateById hook (uses updateOne internally)
+  app.tracker.clear();
+  await app.users.updateById(user1.id, { email: "alice.new@example.com" });
+
+  expect(app.tracker.find("update:before")).toHaveLength(1);
+  expect(app.tracker.find("update:after")).toHaveLength(1);
+
+  // Test: updateMany hook
+  app.tracker.clear();
+  const allBeforeUpdate = await app.users.findMany();
+  const bobAndCharlie = allBeforeUpdate.filter(
+    (u) => u.name === "Bob" || u.name === "Charlie",
+  );
+  await app.users.updateMany(
+    {
+      or: [{ name: { eq: "Bob" } }, { name: { eq: "Charlie" } }],
+    },
+    { email: "updated@example.com" },
+  );
+
+  expect(app.tracker.find("update:before")).toHaveLength(1);
+  expect(app.tracker.find("update:after")).toHaveLength(1);
+
+  const updateManyAfterEvent = app.tracker.findLast("update:after");
+  expect(updateManyAfterEvent.data.entities.length).toBeGreaterThanOrEqual(2);
+
+  // Test: save hook (uses updateOne internally)
+  app.tracker.clear();
+  const userToSave = await app.users.findById(user1.id);
+  userToSave.name = "Alice Saved";
+  await app.users.save(userToSave);
+
+  // save calls find (read) once, and updateOne (update) once
+  expect(app.tracker.find("read:before").length).toBeGreaterThanOrEqual(1);
+  expect(app.tracker.find("read:after").length).toBeGreaterThanOrEqual(1);
+  expect(app.tracker.find("update:before")).toHaveLength(1);
+  expect(app.tracker.find("update:after")).toHaveLength(1);
+
+  // ========================================
+  // DELETE HOOKS
+  // ========================================
+
+  // Test: deleteMany hook
+  app.tracker.clear();
+  const bobUser = bobAndCharlie.find((u) => u.name === "Bob");
+  if (!bobUser) throw new Error("Bob not found");
+
+  await app.users.deleteMany({ id: { eq: bobUser.id } });
+
+  expect(app.tracker.find("delete:before")).toHaveLength(1);
+  expect(app.tracker.find("delete:after")).toHaveLength(1);
+
+  const deleteBeforeEvent = app.tracker.findLast("delete:before");
+  expect(deleteBeforeEvent.data.tableName).toBe("users");
+
+  const deleteAfterEvent = app.tracker.findLast("delete:after");
+  expect(deleteAfterEvent.data.tableName).toBe("users");
+  expect(deleteAfterEvent.data.ids).toHaveLength(1);
+  expect(deleteAfterEvent.data.ids[0]).toBe(bobUser.id);
+
+  // Test: deleteOne hook (uses deleteMany internally)
+  app.tracker.clear();
+  const charlieUser = bobAndCharlie.find((u) => u.name === "Charlie");
+  if (!charlieUser) throw new Error("Charlie not found");
+
+  await app.users.deleteOne({ id: { eq: charlieUser.id } });
+
+  expect(app.tracker.find("delete:before")).toHaveLength(1);
+  expect(app.tracker.find("delete:after")).toHaveLength(1);
+
+  // Test: deleteById hook (uses deleteMany internally)
+  app.tracker.clear();
+  const remainingUsers = await app.users.findMany();
+  const lastUser = remainingUsers[0];
+
+  await app.users.deleteById(lastUser.id);
+
+  expect(app.tracker.find("delete:before")).toHaveLength(1);
+  expect(app.tracker.find("delete:after")).toHaveLength(1);
+
+  // ========================================
+  // HOOK ORDER VERIFICATION
+  // ========================================
+
+  // Test: hooks fire in correct order (before -> after)
+  app.tracker.clear();
+  await app.users.create({ name: "Test", email: "test@example.com" });
+
+  const allEvents = app.tracker.events.map((e) => e.name);
+  const createBeforeIndex = allEvents.indexOf("create:before");
+  const createAfterIndex = allEvents.indexOf("create:after");
+
+  expect(createBeforeIndex).toBeLessThan(createAfterIndex);
+};
+
+describe("$repository - Hooks", () => {
+  it("should fire hooks for all operations (postgres)", async () => {
+    await testRepositoryHooks(Alepha.create());
+  });
+
+  it("should fire hooks for all operations (pglite)", async () => {
+    process.env.DATABASE_URL = "pglite://:memory:";
+    await testRepositoryHooks(Alepha.create());
+  });
+
+  it("should fire hooks for all operations (sqlite)", async () => {
+    process.env.DATABASE_URL = "sqlite://:memory:";
+    await testRepositoryHooks(Alepha.create());
+  });
+});