alepha 0.14.2 → 0.14.4

package/src/orm/__tests__/delete-returning.spec.ts

@@ -0,0 +1,256 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { DbEntityNotFoundError } from "../errors/DbEntityNotFoundError.ts";
+import { $entity, $repository } from "../index.ts";
+import { pg } from "../providers/DatabaseTypeProvider.ts";
+
+// Test entity
+const userEntity = $entity({
+  name: "users",
+  schema: t.object({
+    id: pg.primaryKey(),
+    name: t.string(),
+    email: t.email(),
+    active: t.boolean(),
+  }),
+});
+
+const postEntity = $entity({
+  name: "posts",
+  schema: t.object({
+    id: pg.primaryKey(),
+    userId: t.integer(),
+    title: t.string(),
+    content: t.text(),
+  }),
+});
+
+class TestApp {
+  users = $repository(userEntity);
+  posts = $repository(postEntity);
+}
+
+/**
+ * Shared test function that runs on both PostgreSQL and SQLite
+ */
+const testDeleteReturning = async (alepha: Alepha) => {
+  const app = alepha.inject(TestApp);
+  await alepha.start();
+
+  // Test 1: deleteById returns the deleted ID
+  const user1 = await app.users.create({
+    name: "Alice",
+    email: "alice@example.com",
+    active: true,
+  });
+
+  const deletedIds = await app.users.deleteById(user1.id);
+  expect(deletedIds).toHaveLength(1);
+  expect(deletedIds[0]).toBe(user1.id);
+
+  // Verify the user is deleted
+  await expect(app.users.findById(user1.id)).rejects.toThrow(
+    DbEntityNotFoundError,
+  );
+
+  // Test 2: deleteById throws error when entity not found
+  await expect(app.users.deleteById(999999)).rejects.toThrow(
+    DbEntityNotFoundError,
+  );
+
+  // Test 3: deleteMany returns array of deleted IDs
+  const users = await Promise.all([
+    app.users.create({ name: "Bob", email: "bob@example.com", active: true }),
+    app.users.create({
+      name: "Charlie",
+      email: "charlie@example.com",
+      active: false,
+    }),
+    app.users.create({
+      name: "David",
+      email: "david@example.com",
+      active: true,
+    }),
+  ]);
+
+  const activeUserIds = users
+    .filter((u) => u.active)
+    .map((u) => u.id)
+    .sort((a, b) => a - b);
+
+  const deletedActiveIds = await app.users.deleteMany({
+    active: { eq: true },
+  });
+
+  expect(deletedActiveIds).toHaveLength(2);
+  expect(deletedActiveIds.sort((a, b) => Number(a) - Number(b))).toEqual(
+    activeUserIds,
+  );
+
+  // Verify only inactive user remains
+  const remaining = await app.users.findMany({});
+  expect(remaining).toHaveLength(1);
+  expect(remaining[0].name).toBe("Charlie");
+
+  // Test 4: deleteOne returns array with single ID
+  const deletedOneIds = await app.users.deleteOne({
+    email: { eq: "charlie@example.com" },
+  });
+  expect(deletedOneIds).toHaveLength(1);
+  expect(deletedOneIds[0]).toBe(users[1].id);
+
+  // Test 5: clear returns all deleted IDs
+  const moreUsers = await Promise.all([
+    app.users.create({ name: "Eve", email: "eve@example.com", active: true }),
+    app.users.create({
+      name: "Frank",
+      email: "frank@example.com",
+      active: false,
+    }),
+    app.users.create({
+      name: "Grace",
+      email: "grace@example.com",
+      active: true,
+    }),
+  ]);
+
+  const allIds = moreUsers.map((u) => u.id).sort((a, b) => a - b);
+  const clearedIds = await app.users.clear();
+
+  expect(clearedIds).toHaveLength(3);
+  expect(clearedIds.sort((a, b) => Number(a) - Number(b))).toEqual(allIds);
+
+  // Verify table is empty
+  expect(await app.users.count()).toBe(0);
+
+  // Test 6: destroy returns the deleted ID
+  const user = await app.users.create({
+    name: "Helen",
+    email: "helen@example.com",
+    active: true,
+  });
+
+  const destroyedIds = await app.users.destroy(user);
+  expect(destroyedIds).toHaveLength(1);
+  expect(destroyedIds[0]).toBe(user.id);
+
+  // Test 7: deleteMany with no matches returns empty array
+  const emptyResult = await app.users.deleteMany({
+    name: { eq: "NonExistent" },
+  });
+  expect(emptyResult).toHaveLength(0);
+
+  // Test 8: Test with composite operations
+  const posts = await Promise.all([
+    app.posts.create({
+      userId: 1,
+      title: "Post 1",
+      content: "Content 1",
+    }),
+    app.posts.create({
+      userId: 1,
+      title: "Post 2",
+      content: "Content 2",
+    }),
+    app.posts.create({
+      userId: 2,
+      title: "Post 3",
+      content: "Content 3",
+    }),
+  ]);
+
+  const deletedPostIds = await app.posts.deleteMany({
+    userId: { eq: 1 },
+  });
+
+  expect(deletedPostIds).toHaveLength(2);
+  const sortedDeletedIds = deletedPostIds.sort((a, b) => Number(a) - Number(b));
+  const expectedIds = [posts[0].id, posts[1].id].sort((a, b) => a - b);
+  expect(sortedDeletedIds).toEqual(expectedIds);
+
+  // Clean up
+  await app.posts.clear({ force: true });
+  await app.users.clear({ force: true });
+};
+
+describe("Delete methods with returning IDs", () => {
+  it("should return deleted IDs in PostgreSQL", async () => {
+    await testDeleteReturning(Alepha.create());
+  });
+
+  it("should return deleted IDs in SQLite", async () => {
+    await testDeleteReturning(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+
+  it("should handle soft delete with returning IDs", async () => {
+    // Test entity with soft delete
+    const softEntity = $entity({
+      name: "soft_delete_items",
+      schema: t.object({
+        id: pg.primaryKey(),
+        name: t.string(),
+        deletedAt: pg.deletedAt(),
+      }),
+    });
+
+    class SoftDeleteApp {
+      items = $repository(softEntity);
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(SoftDeleteApp);
+    await alepha.start();
+
+    // Create test items
+    const item1 = await app.items.create({ name: "Item 1" });
+    const item2 = await app.items.create({ name: "Item 2" });
+    const item3 = await app.items.create({ name: "Item 3" });
+
+    // Test soft delete by ID - this should trigger soft delete
+    const softDeletedId = await app.items.deleteById(item1.id);
+    expect(softDeletedId).toHaveLength(1);
+    expect(softDeletedId[0]).toBe(item1.id);
+
+    // Item should still exist but be soft deleted
+    const allAfterSoftDelete = await app.items.findMany({}, { force: true });
+    expect(allAfterSoftDelete).toHaveLength(3);
+
+    const activeAfterSoftDelete = await app.items.findMany({});
+    expect(activeAfterSoftDelete).toHaveLength(2);
+    expect(activeAfterSoftDelete.map((i) => i.name).sort()).toEqual([
+      "Item 2",
+      "Item 3",
+    ]);
+
+    // Test soft delete multiple items
+    const softDeletedIds = await app.items.deleteMany({
+      name: { inArray: ["Item 2", "Item 3"] },
+    });
+
+    expect(softDeletedIds).toHaveLength(2);
+    const sortedIds = softDeletedIds.sort((a, b) => Number(a) - Number(b));
+    const expectedIds = [item2.id, item3.id].sort((a, b) => a - b);
+    expect(sortedIds).toEqual(expectedIds);
+
+    // All items should be soft deleted now
+    const allItems = await app.items.findMany({}, { force: true });
+    expect(allItems).toHaveLength(3);
+
+    const activeItems = await app.items.findMany({});
+    expect(activeItems).toHaveLength(0);
+
+    // Force delete returns IDs
+    const forceDeletedIds = await app.items.clear({ force: true });
+    expect(forceDeletedIds).toHaveLength(3);
+
+    // Table should be empty now
+    const finalItems = await app.items.findMany({}, { force: true });
+    expect(finalItems).toHaveLength(0);
+  });
+});

package/src/orm/__tests__/deletedAt.spec.ts

@@ -0,0 +1,80 @@
+import { Alepha, t } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { describe, it } from "vitest";
+import { $entity, $repository, DbEntityNotFoundError, pg } from "../index.ts";
+
+describe("deletedAt", () => {
+  const entity = $entity({
+    name: "test_entity",
+    schema: t.object({
+      id: pg.primaryKey(),
+      deletedAt: pg.deletedAt(),
+      name: t.optional(t.text()),
+    }),
+  });
+
+  class App {
+    repository = $repository(entity);
+  }
+
+  const setup = async () => {
+    const alepha = Alepha.create();
+    const app = alepha.inject(App);
+    await alepha.start();
+    const now = alepha.inject(DateTimeProvider).pause();
+    return {
+      repository: app.repository,
+      now: now.toISOString(),
+    };
+  };
+
+  it("should update instead of delete", async ({ expect }) => {
+    const { repository, now } = await setup();
+
+    await repository.createMany([{}, {}]);
+    const entities = await repository.findMany();
+    expect(entities.length).toEqual(2);
+    expect(await repository.count()).toEqual(2);
+
+    await repository.deleteById(entities[0].id);
+    expect(await repository.count()).toEqual(1);
+    expect(await repository.findMany()).toEqual([{ id: entities[1].id }]);
+
+    expect(await repository.count({}, { force: true })).toEqual(2);
+    expect(await repository.findMany({}, { force: true })).toEqual([
+      { id: entities[1].id },
+      { id: entities[0].id, deletedAt: now },
+    ]);
+  });
+
+  it("should not update if deletedAt is already set", async ({ expect }) => {
+    const { repository, now } = await setup();
+    await repository.createMany([{}, {}]);
+    const entities = await repository.findMany();
+    const it = entities[0];
+    await repository.destroy(it);
+    it.name = "Toby";
+    await expect(() => repository.save(it)).rejects.toThrow(
+      DbEntityNotFoundError,
+    );
+    await repository.save(it, { force: true });
+    expect(await repository.findById(it.id, { force: true })).toEqual({
+      id: it.id,
+      deletedAt: now,
+      name: "Toby",
+    });
+  });
+
+  it("should force delete", async ({ expect }) => {
+    const { repository } = await setup();
+    await repository.createMany([{}, {}]);
+    const entities = await repository.findMany();
+    const it = entities[0];
+    await repository.destroy(it);
+    expect(await repository.count()).toEqual(1);
+    expect(await repository.count({}, { force: true })).toEqual(2);
+    await repository.destroy(it, { force: true });
+    expect(await repository.count()).toEqual(1);
+    expect(await repository.count({}, { force: true })).toEqual(1);
+  });
+});

package/src/orm/__tests__/enums.spec.ts

@@ -0,0 +1,315 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $entity, $repository, DrizzleKitProvider, pg } from "../index.ts";
+
+// Test 1: Basic enum using t.enum (should map to TEXT column)
+const textEnumEntity = $entity({
+  name: "text_enum_test",
+  schema: t.object({
+    id: pg.primaryKey(),
+    status: t.enum(["pending", "active", "archived"]),
+    role: t.enum(["user", "admin", "moderator"]),
+  }),
+});
+
+// Test 2: Basic enum using pg.enum (should create real PG ENUM type)
+const pgEnumEntity = $entity({
+  name: "pg_enum_test",
+  schema: t.object({
+    id: pg.primaryKey(),
+    status: pg.enum(["draft", "published", "deleted"]),
+    priority: pg.enum(["low", "medium", "high"]),
+  }),
+});
+
+// Test 3: Mixed t.enum and pg.enum in the same table
+const mixedEnumEntity = $entity({
+  name: "mixed_enum_test",
+  schema: t.object({
+    id: pg.primaryKey(),
+    textStatus: t.enum(["open", "closed"]),
+    pgStatus: pg.enum(["new", "in_progress", "done"]),
+  }),
+});
+
+// Test 4: Shared enum with custom name across two tables
+const sharedEnumEntity1 = $entity({
+  name: "shared_enum_test_1",
+  schema: t.object({
+    id: pg.primaryKey(),
+    status: pg.enum(["enabled", "disabled"], { name: "shared_status_enum" }),
+  }),
+});
+
+const sharedEnumEntity2 = $entity({
+  name: "shared_enum_test_2",
+  schema: t.object({
+    id: pg.primaryKey(),
+    status: pg.enum(["enabled", "disabled"], { name: "shared_status_enum" }),
+  }),
+});
+
+// Test 5: Conflicting enum - same name but different values (should throw error)
+const conflictEnumEntity1 = $entity({
+  name: "conflict_enum_test_1",
+  schema: t.object({
+    id: pg.primaryKey(),
+    status: pg.enum(["a", "b", "c"], { name: "conflict_status_enum" }),
+  }),
+});
+
+const conflictEnumEntity2 = $entity({
+  name: "conflict_enum_test_2",
+  schema: t.object({
+    id: pg.primaryKey(),
+    status: pg.enum(["a", "b", "d"], { name: "conflict_status_enum" }), // Different value!
+  }),
+});
+
+describe("enums - t.enum (TEXT column)", () => {
+  it("should create TEXT columns for t.enum fields", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository = $repository(textEnumEntity);
+    }
+
+    const app = alepha.inject(App);
+    const drizzleKit = alepha.inject(DrizzleKitProvider);
+
+    await alepha.start();
+
+    // Check generated SQL
+    const { statements: sql } = await drizzleKit.generateMigration(
+      app.repository.provider,
+    );
+
+    expect(sql).toContainEqual(expect.stringContaining("CREATE TABLE"));
+    expect(sql).toContainEqual(expect.stringContaining("text_enum_test"));
+    // t.enum should map to TEXT, not a real ENUM type
+    expect(sql.some((s) => s.includes('"status" text'))).toBe(true);
+    expect(sql.some((s) => s.includes('"role" text'))).toBe(true);
+  });
+
+  it("should allow inserting and querying with t.enum values", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository = $repository(textEnumEntity);
+    }
+
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    const created = await app.repository.create({
+      status: "pending",
+      role: "user",
+    });
+
+    expect(created.status).toBe("pending");
+    expect(created.role).toBe("user");
+    expect(created.id).toBeDefined();
+
+    const found = await app.repository.findOne({ where: { id: created.id } });
+    expect(found?.status).toBe("pending");
+    expect(found?.role).toBe("user");
+  });
+});
+
+describe("enums - pg.enum (real PG ENUM type)", () => {
+  it("should create real PostgreSQL ENUM types for pg.enum fields", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository = $repository(pgEnumEntity);
+    }
+
+    const app = alepha.inject(App);
+    const drizzleKit = alepha.inject(DrizzleKitProvider);
+
+    await alepha.start();
+
+    // Check generated SQL
+    const { statements: sql } = await drizzleKit.generateMigration(
+      app.repository.provider,
+    );
+
+    expect(sql).toContainEqual(expect.stringContaining("CREATE TABLE"));
+    expect(sql).toContainEqual(expect.stringContaining("pg_enum_test"));
+    // pg.enum should create real ENUM types
+    expect(
+      sql.some((s) => s.includes("CREATE TYPE") || s.includes("DO $$ BEGIN")),
+    ).toBe(true);
+  });
+
+  it("should allow inserting and querying with pg.enum values", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository = $repository(pgEnumEntity);
+    }
+
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    const created = await app.repository.create({
+      status: "draft",
+      priority: "high",
+    });
+
+    expect(created.status).toBe("draft");
+    expect(created.priority).toBe("high");
+    expect(created.id).toBeDefined();
+
+    const found = await app.repository.findOne({ where: { id: created.id } });
+    expect(found?.status).toBe("draft");
+    expect(found?.priority).toBe("high");
+  });
+});
+
+describe("enums - mixed t.enum and pg.enum in same table", () => {
+  it("should handle both TEXT and PG ENUM types in the same table", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository = $repository(mixedEnumEntity);
+    }
+
+    const app = alepha.inject(App);
+    const drizzleKit = alepha.inject(DrizzleKitProvider);
+
+    await alepha.start();
+
+    // Check generated SQL
+    const { statements: sql } = await drizzleKit.generateMigration(
+      app.repository.provider,
+    );
+
+    expect(sql).toContainEqual(expect.stringContaining("CREATE TABLE"));
+    expect(sql).toContainEqual(expect.stringContaining("mixed_enum_test"));
+    // textStatus should be TEXT
+    expect(
+      sql.some(
+        (s) =>
+          s.includes('"text_status" text') || s.includes('"textStatus" text'),
+      ),
+    ).toBe(true);
+    // pgStatus should create an ENUM type
+    expect(
+      sql.some((s) => s.includes("CREATE TYPE") || s.includes("DO $$ BEGIN")),
+    ).toBe(true);
+  });
+
+  it("should allow inserting and querying with mixed enum values", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository = $repository(mixedEnumEntity);
+    }
+
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    const created = await app.repository.create({
+      textStatus: "open",
+      pgStatus: "new",
+    });
+
+    expect(created.textStatus).toBe("open");
+    expect(created.pgStatus).toBe("new");
+    expect(created.id).toBeDefined();
+
+    const found = await app.repository.findOne({ where: { id: created.id } });
+    expect(found?.textStatus).toBe("open");
+    expect(found?.pgStatus).toBe("new");
+  });
+});
+
+describe("enums - shared enum with custom name across tables", () => {
+  it("should reuse the same PG ENUM type across multiple tables", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository1 = $repository(sharedEnumEntity1);
+      repository2 = $repository(sharedEnumEntity2);
+    }
+
+    const app = alepha.inject(App);
+    const drizzleKit = alepha.inject(DrizzleKitProvider);
+
+    await alepha.start();
+
+    // Check generated SQL
+    const { statements: sql } = await drizzleKit.generateMigration(
+      app.repository1.provider,
+    );
+
+    // Count how many times the shared_status_enum is created
+    // It should only be created once, even though it's used in two tables
+    const enumCreations = sql.filter(
+      (s) =>
+        s.includes("shared_status_enum") &&
+        (s.includes("CREATE TYPE") || s.includes("DO $$ BEGIN")),
+    );
+
+    // Should only create the enum type once
+    expect(enumCreations.length).toBeLessThanOrEqual(1);
+
+    // Both tables should exist
+    expect(sql.some((s) => s.includes("shared_enum_test_1"))).toBe(true);
+    expect(sql.some((s) => s.includes("shared_enum_test_2"))).toBe(true);
+  });
+
+  it("should allow both tables to use the shared enum values", async () => {
+    const alepha = Alepha.create();
+
+    class App {
+      repository1 = $repository(sharedEnumEntity1);
+      repository2 = $repository(sharedEnumEntity2);
+    }
+
+    const app = alepha.inject(App);
+    await alepha.start();
+
+    const created1 = await app.repository1.create({
+      status: "enabled",
+    });
+
+    const created2 = await app.repository2.create({
+      status: "disabled",
+    });
+
+    expect(created1.status).toBe("enabled");
+    expect(created2.status).toBe("disabled");
+
+    const found1 = await app.repository1.findOne({
+      where: { id: created1.id },
+    });
+    const found2 = await app.repository2.findOne({
+      where: { id: created2.id },
+    });
+
+    expect(found1?.status).toBe("enabled");
+    expect(found2?.status).toBe("disabled");
+  });
+});
+
+describe("enums - conflict detection with different values", () => {
+  it("should throw error when same enum name has different values", async () => {
+    const alepha = Alepha.create();
+
+    const load = async () => {
+      return alepha.with(() => ({
+        r1: $repository(conflictEnumEntity1),
+        r2: $repository(conflictEnumEntity2),
+      }));
+    };
+
+    expect(() =>
+      alepha.with(() => ({
+        r1: $repository(conflictEnumEntity1),
+        r2: $repository(conflictEnumEntity2),
+      })),
+    ).toThrow(/Enum name conflict/i);
+  });
+});