alepha 0.14.1 → 0.14.3

package/src/orm/__tests__/ModelBuilder-integration.spec.ts

@@ -0,0 +1,490 @@
+import { Alepha, t } from "alepha";
+import { sql } from "drizzle-orm";
+import { describe, expect, it } from "vitest";
+import { $entity, $repository } from "../index.ts";
+import { pg } from "../providers/DatabaseTypeProvider.ts";
+
+// Define test entities with all features
+const roleEntity = $entity({
+  name: "roles",
+  schema: t.object({
+    id: pg.primaryKey(),
+    name: t.string(),
+    description: t.optional(t.string()),
+  }),
+  indexes: ["name"],
+  constraints: [
+    {
+      columns: ["name"],
+      unique: true,
+      name: "unique_role_name",
+    },
+  ],
+});
+
+const userEntity = $entity({
+  name: "users",
+  schema: t.object({
+    id: pg.primaryKey(),
+    email: t.email(),
+    username: t.string(),
+    age: t.integer(),
+    roleId: t.integer(),
+    status: t.string(),
+  }),
+  indexes: [
+    // Simple index
+    "email",
+    // Unique index with name
+    {
+      column: "username",
+      unique: true,
+      name: "unique_username_idx",
+    },
+    // Composite index
+    {
+      columns: ["roleId", "status"],
+      name: "role_status_idx",
+    },
+  ],
+  foreignKeys: [
+    {
+      columns: ["roleId"],
+      foreignColumns: [() => roleEntity.cols.id],
+    },
+  ],
+  constraints: [
+    // Check constraint
+    {
+      columns: ["age"],
+      check: sql`age >= 18 AND age <= 120`,
+      name: "valid_age_range",
+    },
+    // Composite unique constraint
+    {
+      columns: ["email", "username"],
+      unique: true,
+      name: "unique_email_username",
+    },
+  ],
+});
+
+const postEntity = $entity({
+  name: "posts",
+  schema: t.object({
+    id: pg.primaryKey(),
+    userId: t.integer(),
+    title: t.string(),
+    content: t.text(),
+    published: t.boolean(),
+    views: t.integer(),
+    tags: t.optional(t.array(t.string())),
+  }),
+  indexes: [
+    // Multiple indexes
+    "title",
+    {
+      column: "published",
+      name: "published_idx",
+    },
+    {
+      columns: ["userId", "published"],
+      name: "user_published_idx",
+    },
+    {
+      columns: ["userId", "views"],
+      unique: true,
+      name: "unique_user_views",
+    },
+  ],
+  foreignKeys: [
+    {
+      name: "posts_user_fk",
+      columns: ["userId"],
+      foreignColumns: [() => userEntity.cols.id],
+    },
+  ],
+  constraints: [
+    {
+      columns: ["views"],
+      check: sql`views >= 0`,
+      name: "positive_views",
+    },
+  ],
+});
+
+// Test app with repositories
+class TestApp {
+  roles = $repository(roleEntity);
+  users = $repository(userEntity);
+  posts = $repository(postEntity);
+}
+
+/**
+ * Shared test function that runs on both PostgreSQL and SQLite
+ */
+const testModelBuilderFeatures = async (alepha: Alepha) => {
+  const app = alepha.inject(TestApp);
+  await alepha.start();
+
+  // Test 1: Create roles (tests unique constraint on name)
+  const adminRole = await app.roles.create({
+    name: "admin",
+    description: "Administrator role",
+  });
+  expect(adminRole.id).toBeDefined();
+  expect(adminRole.name).toBe("admin");
+
+  const userRole = await app.roles.create({
+    name: "user",
+    description: "Regular user role",
+  });
+  expect(userRole.id).toBeDefined();
+
+  // Test unique constraint violation
+  try {
+    await app.roles.create({
+      name: "admin", // Duplicate name
+      description: "Another admin",
+    });
+    expect.fail("Should have thrown unique constraint error");
+  } catch (error: any) {
+    // Expected: unique constraint violation
+    expect(error).toBeDefined();
+  }
+
+  // Test 2: Create users (tests foreign key, check constraint, and unique indexes)
+  const user1 = await app.users.create({
+    email: "alice@example.com",
+    username: "alice",
+    age: 25,
+    roleId: adminRole.id,
+    status: "active",
+  });
+  expect(user1.id).toBeDefined();
+  expect(user1.username).toBe("alice");
+
+  const user2 = await app.users.create({
+    email: "bob@example.com",
+    username: "bob",
+    age: 30,
+    roleId: userRole.id,
+    status: "active",
+  });
+  expect(user2.id).toBeDefined();
+
+  // Test unique index on username
+  try {
+    await app.users.create({
+      email: "charlie@example.com",
+      username: "alice", // Duplicate username
+      age: 28,
+      roleId: userRole.id,
+      status: "active",
+    });
+    expect.fail("Should have thrown unique constraint error on username");
+  } catch (error: any) {
+    // Expected: unique constraint violation
+    expect(error).toBeDefined();
+  }
+
+  // Test check constraint (age must be >= 18)
+  try {
+    await app.users.create({
+      email: "young@example.com",
+      username: "younguser",
+      age: 15, // Below minimum age
+      roleId: userRole.id,
+      status: "pending",
+    });
+    expect.fail("Should have thrown check constraint error for age");
+  } catch (error: any) {
+    // Expected: check constraint violation
+    expect(error).toBeDefined();
+  }
+
+  // Test composite unique constraint (email + username)
+  try {
+    await app.users.create({
+      email: "alice@example.com", // Same email as user1
+      username: "alice", // Same username as user1
+      age: 22,
+      roleId: userRole.id,
+      status: "inactive",
+    });
+    expect.fail("Should have thrown composite unique constraint error");
+  } catch (error: any) {
+    // Expected: composite unique constraint violation
+    expect(error).toBeDefined();
+  }
+
+  // Test 3: Create posts (tests multiple indexes and foreign key)
+  const post1 = await app.posts.create({
+    userId: user1.id,
+    title: "First Post",
+    content: "This is the first post",
+    published: true,
+    views: 100,
+  });
+  expect(post1.id).toBeDefined();
+  expect(post1.views).toBe(100);
+
+  const post2 = await app.posts.create({
+    userId: user1.id,
+    title: "Second Post",
+    content: "This is the second post",
+    published: false,
+    views: 50,
+    tags: ["tech", "tutorial"],
+  });
+  expect(post2.id).toBeDefined();
+  expect(post2.tags).toEqual(["tech", "tutorial"]);
+
+  // Test check constraint (views must be >= 0)
+  try {
+    await app.posts.create({
+      userId: user2.id,
+      title: "Invalid Post",
+      content: "This post has negative views",
+      published: true,
+      views: -10, // Negative views
+    });
+    expect.fail("Should have thrown check constraint error for views");
+  } catch (error: any) {
+    // Expected: check constraint violation
+    expect(error).toBeDefined();
+  }
+
+  // Test unique index on (userId, views) - only for testing unique composite index
+  try {
+    await app.posts.create({
+      userId: user1.id,
+      title: "Duplicate Views Post",
+      content: "This has the same userId and views",
+      published: true,
+      views: 100, // Same views as post1 for same user
+    });
+    expect.fail(
+      "Should have thrown unique constraint error on (userId, views)",
+    );
+  } catch (error: any) {
+    // Expected: unique constraint violation
+    expect(error).toBeDefined();
+  }
+
+  // Test 4: Query using indexes (verify they improve query performance)
+  // Find users by email (uses email index)
+  const usersByEmail = await app.users.findMany({
+    where: { email: { eq: "alice@example.com" } },
+  });
+  expect(usersByEmail.length).toBe(1);
+  expect(usersByEmail[0].username).toBe("alice");
+
+  // Find users by roleId and status (uses composite index)
+  const adminUsers = await app.users.findMany({
+    where: { roleId: { eq: adminRole.id } },
+    orderBy: "status",
+  });
+  expect(adminUsers.length).toBeGreaterThan(0);
+  expect(adminUsers[0].roleId).toBe(adminRole.id);
+
+  // Find posts by userId and published status (uses composite index)
+  const publishedPosts = await app.posts.findMany({
+    where: {
+      userId: { eq: user1.id },
+      published: { eq: true },
+    },
+  });
+  expect(publishedPosts.length).toBeGreaterThan(0);
+  expect(publishedPosts[0].published).toBe(true);
+
+  // Test 5: Foreign key cascade behavior
+  // When we delete a user, their posts should be affected based on FK settings
+  // (Note: The actual cascade behavior depends on the FK configuration)
+
+  // Clean up
+  await app.posts.clear({ force: true });
+  await app.users.clear({ force: true });
+  await app.roles.clear({ force: true });
+};
+
+describe("ModelBuilder Integration Tests", () => {
+  it("should handle all entity options correctly in PostgreSQL", async () => {
+    await testModelBuilderFeatures(Alepha.create());
+  });
+
+  it("should handle all entity options correctly in SQLite", async () => {
+    await testModelBuilderFeatures(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+
+  it("should handle entities with custom config in PostgreSQL", async () => {
+    // Test entity with custom config function
+    const customEntity = $entity({
+      name: "custom_table",
+      schema: t.object({
+        id: pg.primaryKey(),
+        data: t.string(),
+      }),
+      config: (self) => {
+        // Custom config could add additional indexes, constraints, etc.
+        // This is called during table creation
+        return [];
+      },
+    });
+
+    class CustomApp {
+      custom = $repository(customEntity);
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(CustomApp);
+    await alepha.start();
+
+    const record = await app.custom.create({
+      data: "test data",
+    });
+    expect(record.id).toBeDefined();
+    expect(record.data).toBe("test data");
+
+    await app.custom.clear({ force: true });
+  });
+
+  it("should handle entities with custom config in SQLite", async () => {
+    // Test entity with custom config function
+    const customEntity = $entity({
+      name: "custom_table_sqlite",
+      schema: t.object({
+        id: pg.primaryKey(),
+        data: t.string(),
+      }),
+      config: (self) => {
+        // Custom config for SQLite
+        return [];
+      },
+    });
+
+    class CustomApp {
+      custom = $repository(customEntity);
+    }
+
+    const alepha = Alepha.create({
+      env: {
+        DATABASE_URL: "sqlite://:memory:",
+      },
+    });
+    const app = alepha.inject(CustomApp);
+    await alepha.start();
+
+    const record = await app.custom.create({
+      data: "test data sqlite",
+    });
+    expect(record.id).toBeDefined();
+    expect(record.data).toBe("test data sqlite");
+
+    await app.custom.clear({ force: true });
+  });
+
+  it("should handle complex nested relationships", async () => {
+    const testComplexRelationships = async (alepha: Alepha) => {
+      // Category -> Product -> OrderItem -> Order -> User
+      const categoryEntity = $entity({
+        name: "categories",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.string(),
+        }),
+        indexes: [
+          {
+            column: "name",
+            unique: true,
+          },
+        ],
+      });
+
+      const productEntity = $entity({
+        name: "products",
+        schema: t.object({
+          id: pg.primaryKey(),
+          name: t.string(),
+          categoryId: t.integer(),
+          price: t.number(),
+        }),
+        indexes: [
+          "name",
+          {
+            columns: ["categoryId", "price"],
+            name: "category_price_idx",
+          },
+        ],
+        foreignKeys: [
+          {
+            columns: ["categoryId"],
+            foreignColumns: [() => categoryEntity.cols.id],
+          },
+        ],
+        constraints: [
+          {
+            columns: ["price"],
+            check: sql`price > 0`,
+            name: "positive_price",
+          },
+        ],
+      });
+
+      class ComplexApp {
+        categories = $repository(categoryEntity);
+        products = $repository(productEntity);
+      }
+
+      const app = alepha.inject(ComplexApp);
+      await alepha.start();
+
+      // Create test data
+      const electronics = await app.categories.create({
+        name: "Electronics",
+      });
+
+      const laptop = await app.products.create({
+        name: "Laptop",
+        categoryId: electronics.id,
+        price: 999.99,
+      });
+
+      expect(laptop.categoryId).toBe(electronics.id);
+      expect(laptop.price).toBe(999.99);
+
+      // Test constraint
+      try {
+        await app.products.create({
+          name: "Invalid Product",
+          categoryId: electronics.id,
+          price: -10, // Invalid price
+        });
+        expect.fail("Should have thrown check constraint error");
+      } catch (error) {
+        // Expected
+        expect(error).toBeDefined();
+      }
+
+      // Clean up
+      await app.products.clear({ force: true });
+      await app.categories.clear({ force: true });
+    };
+
+    // Test on both databases
+    await testComplexRelationships(Alepha.create());
+    await testComplexRelationships(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+});

package/src/orm/__tests__/ModelBuilder-types.spec.ts

@@ -0,0 +1,186 @@
+import { t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $entity } from "../primitives/$entity.ts";
+import { pg } from "../providers/DatabaseTypeProvider.ts";
+
+describe("ModelBuilder Type Safety", () => {
+  it("should enforce type-safe foreign key references", () => {
+    const roleEntity = $entity({
+      name: "roles",
+      schema: t.object({
+        id: pg.primaryKey(),
+        name: t.string(),
+      }),
+    });
+
+    const userEntity = $entity({
+      name: "users",
+      schema: t.object({
+        id: pg.primaryKey(),
+        email: t.email(),
+        roleId: t.integer(),
+      }),
+      foreignKeys: [
+        {
+          columns: ["roleId"],
+          // This should reference an EntityColumn from roleEntity
+          foreignColumns: [() => roleEntity.cols.id],
+        },
+      ],
+    });
+
+    // Test that we can access the column references
+    expect(roleEntity.cols.id).toBeDefined();
+    expect(roleEntity.cols.id.name).toBe("id");
+    expect(roleEntity.cols.id.entity).toBe(roleEntity);
+
+    expect(userEntity.cols.email).toBeDefined();
+    expect(userEntity.cols.email.name).toBe("email");
+
+    // Test that foreign key references work
+    const fkDef = userEntity.options.foreignKeys![0];
+    expect(fkDef.columns).toEqual(["roleId"]);
+
+    // Execute the foreign column reference function
+    const foreignCol = fkDef.foreignColumns[0]();
+    expect(foreignCol).toBeDefined();
+    expect(foreignCol.name).toBe("id");
+    expect(foreignCol.entity.name).toBe("roles");
+  });
+
+  it("should support multiple foreign key references", () => {
+    const categoryEntity = $entity({
+      name: "categories",
+      schema: t.object({
+        id: pg.primaryKey(),
+        name: t.string(),
+      }),
+    });
+
+    const userEntity = $entity({
+      name: "users",
+      schema: t.object({
+        id: pg.primaryKey(),
+        username: t.string(),
+      }),
+    });
+
+    const postEntity = $entity({
+      name: "posts",
+      schema: t.object({
+        id: pg.primaryKey(),
+        title: t.string(),
+        userId: t.integer(),
+        categoryId: t.integer(),
+      }),
+      foreignKeys: [
+        {
+          columns: ["userId"],
+          foreignColumns: [() => userEntity.cols.id],
+        },
+        {
+          columns: ["categoryId"],
+          foreignColumns: [() => categoryEntity.cols.id],
+        },
+      ],
+    });
+
+    const fks = postEntity.options.foreignKeys!;
+    expect(fks).toHaveLength(2);
+
+    // Check first foreign key (userId -> users.id)
+    const userFk = fks[0];
+    const userForeignCol = userFk.foreignColumns[0]();
+    expect(userForeignCol.entity.name).toBe("users");
+    expect(userForeignCol.name).toBe("id");
+
+    // Check second foreign key (categoryId -> categories.id)
+    const categoryFk = fks[1];
+    const categoryForeignCol = categoryFk.foreignColumns[0]();
+    expect(categoryForeignCol.entity.name).toBe("categories");
+    expect(categoryForeignCol.name).toBe("id");
+  });
+
+  it("should support composite foreign keys", () => {
+    const tenantEntity = $entity({
+      name: "tenants",
+      schema: t.object({
+        id: pg.primaryKey(),
+        code: t.string(),
+        name: t.string(),
+      }),
+    });
+
+    const userEntity = $entity({
+      name: "users",
+      schema: t.object({
+        id: pg.primaryKey(),
+        tenantId: t.integer(),
+        tenantCode: t.string(),
+        username: t.string(),
+      }),
+      foreignKeys: [
+        {
+          columns: ["tenantId", "tenantCode"],
+          foreignColumns: [
+            () => tenantEntity.cols.id,
+            () => tenantEntity.cols.code,
+          ],
+        },
+      ],
+    });
+
+    const fk = userEntity.options.foreignKeys![0];
+    expect(fk.columns).toEqual(["tenantId", "tenantCode"]);
+    expect(fk.foreignColumns).toHaveLength(2);
+
+    const foreignCol1 = fk.foreignColumns[0]();
+    const foreignCol2 = fk.foreignColumns[1]();
+
+    expect(foreignCol1.name).toBe("id");
+    expect(foreignCol2.name).toBe("code");
+    expect(foreignCol1.entity.name).toBe("tenants");
+    expect(foreignCol2.entity.name).toBe("tenants");
+  });
+
+  it("should maintain referential integrity through EntityColumn", () => {
+    const entity1 = $entity({
+      name: "entity1",
+      schema: t.object({
+        id: pg.primaryKey(),
+        value: t.string(),
+      }),
+    });
+
+    const entity2 = $entity({
+      name: "entity2",
+      schema: t.object({
+        id: pg.primaryKey(),
+        entity1Id: t.integer(),
+        entity1Value: t.string(),
+      }),
+      foreignKeys: [
+        {
+          name: "entity2_entity1_fk",
+          columns: ["entity1Id", "entity1Value"],
+          foreignColumns: [() => entity1.cols.id, () => entity1.cols.value],
+        },
+      ],
+    });
+
+    // Verify that the foreign key correctly references entity1's columns
+    const fk = entity2.options.foreignKeys![0];
+    expect(fk.name).toBe("entity2_entity1_fk");
+
+    const idRef = fk.foreignColumns[0]();
+    const valueRef = fk.foreignColumns[1]();
+
+    // Both columns should reference the same entity
+    expect(idRef.entity).toBe(valueRef.entity);
+    expect(idRef.entity.name).toBe("entity1");
+
+    // But different columns
+    expect(idRef.name).toBe("id");
+    expect(valueRef.name).toBe("value");
+  });
+});

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

@@ -0,0 +1,46 @@
+import { Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $repository, AlephaPostgres } from "../index.ts";
+import { userEntity } from "./fixtures/userEntitySchema.ts";
+
+describe("PostgresProvider", () => {
+  it("should handle basic CRUD operations with timestamps", async () => {
+    class UserService {
+      users = $repository(userEntity);
+    }
+
+    const alepha = Alepha.create().with(AlephaPostgres);
+
+    const userService = alepha.inject(UserService);
+
+    await alepha.start();
+
+    await userService.users.create({
+      name: "John",
+      profile: {
+        age: 30,
+      },
+    });
+
+    const [r1] = await userService.users.findMany({
+      where: { name: { eq: "John" } },
+    });
+
+    expect(r1.name).toEqual("John");
+    expect(r1.createdAt).toBe(r1.updatedAt);
+
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    const r2 = await userService.users.updateOne(
+      { name: { eq: "John" } },
+      {
+        profile: { age: 31 },
+      },
+    );
+
+    expect(r2.name).toEqual("John");
+    expect(r2.profile.age).toEqual(31);
+    expect(r2.createdAt).toBe(r1.createdAt);
+    expect(r2.updatedAt).not.toBe(r1.updatedAt);
+  });
+});