alepha 0.14.1 → 0.14.3

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

@@ -0,0 +1,128 @@
+import { Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $repository } from "../index.ts";
+import type { InsertUserEntity } from "./fixtures/userEntitySchema.ts";
+import { userEntity } from "./fixtures/userEntitySchema.ts";
+
+class App {
+  users = $repository(userEntity);
+}
+
+const testOrderByModes = async (alepha: Alepha) => {
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // Create test users with different names and roles
+  const users: InsertUserEntity[] = [
+    { name: "Charlie", profile: { age: 25 }, role: "admin" },
+    { name: "Alice", profile: { age: 30 }, role: "user" },
+    { name: "Bob", profile: { age: 20 }, role: "admin" },
+    { name: "David", profile: { age: 35 }, role: "user" },
+  ];
+
+  for (const user of users) {
+    await app.users.create(user);
+  }
+
+  // MODE 1: String (defaults to ASC)
+  const usersMode1 = await app.users.findMany({
+    orderBy: "name",
+  });
+
+  expect(usersMode1.length).toBe(4);
+  expect(usersMode1[0].name).toBe("Alice");
+  expect(usersMode1[1].name).toBe("Bob");
+  expect(usersMode1[2].name).toBe("Charlie");
+  expect(usersMode1[3].name).toBe("David");
+
+  // MODE 2: Single object with direction ASC
+  const usersMode2Asc = await app.users.findMany({
+    orderBy: { column: "name", direction: "asc" },
+  });
+
+  expect(usersMode2Asc.length).toBe(4);
+  expect(usersMode2Asc[0].name).toBe("Alice");
+  expect(usersMode2Asc[1].name).toBe("Bob");
+  expect(usersMode2Asc[2].name).toBe("Charlie");
+  expect(usersMode2Asc[3].name).toBe("David");
+
+  // MODE 2: Single object with direction DESC
+  const usersMode2Desc = await app.users.findMany({
+    orderBy: { column: "name", direction: "desc" },
+  });
+
+  expect(usersMode2Desc.length).toBe(4);
+  expect(usersMode2Desc[0].name).toBe("David");
+  expect(usersMode2Desc[1].name).toBe("Charlie");
+  expect(usersMode2Desc[2].name).toBe("Bob");
+  expect(usersMode2Desc[3].name).toBe("Alice");
+
+  // MODE 2: Single object without direction (defaults to ASC)
+  const usersMode2Default = await app.users.findMany({
+    orderBy: { column: "name" },
+  });
+
+  expect(usersMode2Default.length).toBe(4);
+  expect(usersMode2Default[0].name).toBe("Alice");
+  expect(usersMode2Default[3].name).toBe("David");
+
+  // MODE 3: Array with multiple columns
+  const usersMode3Multi = await app.users.findMany({
+    orderBy: [
+      { column: "role", direction: "asc" },
+      { column: "name", direction: "desc" },
+    ],
+  });
+
+  expect(usersMode3Multi.length).toBe(4);
+  // First by role ASC (admin, admin, user, user)
+  // Then by name DESC within each role
+  expect(usersMode3Multi[0].role).toBe("admin");
+  expect(usersMode3Multi[0].name).toBe("Charlie"); // admin, Charlie
+  expect(usersMode3Multi[1].role).toBe("admin");
+  expect(usersMode3Multi[1].name).toBe("Bob"); // admin, Bob
+  expect(usersMode3Multi[2].role).toBe("user");
+  expect(usersMode3Multi[2].name).toBe("David"); // user, David
+  expect(usersMode3Multi[3].role).toBe("user");
+  expect(usersMode3Multi[3].name).toBe("Alice"); // user, Alice
+
+  // MODE 3: Array with default direction
+  const usersMode3Default = await app.users.findMany({
+    orderBy: [{ column: "role" }, { column: "name" }],
+  });
+
+  expect(usersMode3Default.length).toBe(4);
+  // Both ASC by default
+  expect(usersMode3Default[0].role).toBe("admin");
+  expect(usersMode3Default[0].name).toBe("Bob"); // admin, Bob
+  expect(usersMode3Default[1].role).toBe("admin");
+  expect(usersMode3Default[1].name).toBe("Charlie"); // admin, Charlie
+
+  // MODE 3: Array with single column
+  const usersMode3Single = await app.users.findMany({
+    orderBy: [{ column: "name", direction: "desc" }],
+  });
+
+  expect(usersMode3Single.length).toBe(4);
+  expect(usersMode3Single[0].name).toBe("David");
+  expect(usersMode3Single[3].name).toBe("Alice");
+
+  // Clean up
+  await app.users.clear({ force: true });
+};
+
+describe("$repository - orderBy", () => {
+  it("should support all 3 orderBy modes", async () => {
+    await testOrderByModes(Alepha.create());
+  });
+
+  it("should support all 3 orderBy modes (sqlite)", async () => {
+    await testOrderByModes(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+});

package/src/orm/__tests__/$repository-pagination-sort.spec.ts

@@ -0,0 +1,149 @@
+import { Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $repository } from "../index.ts";
+import type { InsertUserEntity } from "./fixtures/userEntitySchema.ts";
+import { userEntity } from "./fixtures/userEntitySchema.ts";
+
+class App {
+  users = $repository(userEntity);
+}
+
+const testPaginationSort = async (alepha: Alepha) => {
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // Create test users with different names and roles
+  const users: InsertUserEntity[] = [
+    { name: "Charlie", profile: { age: 25 }, role: "admin" },
+    { name: "Alice", profile: { age: 30 }, role: "user" },
+    { name: "Bob", profile: { age: 20 }, role: "admin" },
+    { name: "David", profile: { age: 35 }, role: "user" },
+  ];
+
+  for (const user of users) {
+    await app.users.create(user);
+  }
+
+  // Test 1: Single column ASC (no prefix)
+  const result1 = await app.users.paginate({ sort: "name" });
+
+  expect(result1.content.length).toBe(4);
+  expect(result1.content[0].name).toBe("Alice");
+  expect(result1.content[1].name).toBe("Bob");
+  expect(result1.content[2].name).toBe("Charlie");
+  expect(result1.content[3].name).toBe("David");
+
+  // Test 2: Single column DESC (with - prefix)
+  const result2 = await app.users.paginate({ sort: "-name" });
+
+  expect(result2.content.length).toBe(4);
+  expect(result2.content[0].name).toBe("David");
+  expect(result2.content[1].name).toBe("Charlie");
+  expect(result2.content[2].name).toBe("Bob");
+  expect(result2.content[3].name).toBe("Alice");
+
+  // Test 3: Multiple columns - role ASC, name DESC
+  const result3 = await app.users.paginate({ sort: "role,-name" });
+
+  expect(result3.content.length).toBe(4);
+  // First by role ASC (admin, admin, user, user)
+  // Then by name DESC within each role
+  expect(result3.content[0].role).toBe("admin");
+  expect(result3.content[0].name).toBe("Charlie"); // admin, Charlie
+  expect(result3.content[1].role).toBe("admin");
+  expect(result3.content[1].name).toBe("Bob"); // admin, Bob
+  expect(result3.content[2].role).toBe("user");
+  expect(result3.content[2].name).toBe("David"); // user, David
+  expect(result3.content[3].role).toBe("user");
+  expect(result3.content[3].name).toBe("Alice"); // user, Alice
+
+  // Test 4: Multiple columns - both ASC
+  const result4 = await app.users.paginate({ sort: "role,name" });
+
+  expect(result4.content.length).toBe(4);
+  // Both ASC
+  expect(result4.content[0].role).toBe("admin");
+  expect(result4.content[0].name).toBe("Bob"); // admin, Bob
+  expect(result4.content[1].role).toBe("admin");
+  expect(result4.content[1].name).toBe("Charlie"); // admin, Charlie
+  expect(result4.content[2].role).toBe("user");
+  expect(result4.content[2].name).toBe("Alice"); // user, Alice
+  expect(result4.content[3].role).toBe("user");
+  expect(result4.content[3].name).toBe("David"); // user, David
+
+  // Test 5: Multiple columns - both DESC
+  const result5 = await app.users.paginate({ sort: "-role,-name" });
+
+  expect(result5.content.length).toBe(4);
+  // Both DESC
+  expect(result5.content[0].role).toBe("user");
+  expect(result5.content[0].name).toBe("David"); // user, David
+  expect(result5.content[1].role).toBe("user");
+  expect(result5.content[1].name).toBe("Alice"); // user, Alice
+  expect(result5.content[2].role).toBe("admin");
+  expect(result5.content[2].name).toBe("Charlie"); // admin, Charlie
+  expect(result5.content[3].role).toBe("admin");
+  expect(result5.content[3].name).toBe("Bob"); // admin, Bob
+
+  // Test 6: Pagination with sorting and page size
+  const result6 = await app.users.paginate(
+    { sort: "name", size: 2, page: 0 },
+    {},
+    { count: true },
+  );
+
+  expect(result6.content.length).toBe(2);
+  expect(result6.content[0].name).toBe("Alice");
+  expect(result6.content[1].name).toBe("Bob");
+  expect(result6.page.totalElements).toBe(4);
+  expect(result6.page.totalPages).toBe(2);
+  expect(result6.page.isFirst).toBe(true);
+  expect(result6.page.isLast).toBe(false);
+  expect(result6.page.sort?.sorted).toBe(true);
+  expect(result6.page.sort?.fields).toEqual([
+    { field: "name", direction: "asc" },
+  ]);
+
+  // Test 7: Second page
+  const result7 = await app.users.paginate(
+    { sort: "name", size: 2, page: 1 },
+    {},
+    { count: true },
+  );
+
+  expect(result7.content.length).toBe(2);
+  expect(result7.content[0].name).toBe("Charlie");
+  expect(result7.content[1].name).toBe("David");
+  expect(result7.page.isFirst).toBe(false);
+  expect(result7.page.isLast).toBe(true);
+  expect(result7.page.sort?.sorted).toBe(true);
+  expect(result7.page.sort?.fields).toEqual([
+    { field: "name", direction: "asc" },
+  ]);
+
+  // Test 8: Sort with spaces (should be trimmed)
+  const result8 = await app.users.paginate({ sort: " role , -name " });
+
+  expect(result8.content.length).toBe(4);
+  expect(result8.content[0].role).toBe("admin");
+  expect(result8.content[0].name).toBe("Charlie");
+
+  // Clean up
+  await app.users.clear({ force: true });
+};
+
+describe("$repository - pagination sort", () => {
+  it("should support pagination with new sort format", async () => {
+    await testPaginationSort(Alepha.create());
+  });
+
+  it("should support pagination with new sort format (sqlite)", async () => {
+    await testPaginationSort(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,37 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $entity, $repository, pg } from "../index.ts";
+
+describe("$repository - save", () => {
+  it("should save an entity with deleted fields", async () => {
+    const dummies = $entity({
+      name: "dummies",
+      schema: t.object({
+        id: pg.primaryKey(),
+        name: t.optional(t.text()),
+      }),
+    });
+
+    class App {
+      dummies = $repository(dummies);
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    // Create a new entity
+    const entity = await app.dummies.create({ name: "Test" });
+    expect(await app.dummies.findById(entity.id).then((it) => it.name)).toBe(
+      "Test",
+    );
+
+    // Update the entity to set name to undefined (delete the field)
+    entity.name = undefined;
+    await app.dummies.save(entity);
+    expect(entity.name).toBeUndefined();
+    expect(
+      await app.dummies.findById(entity.id).then((it) => it.name),
+    ).toBeUndefined();
+  });
+});