alepha 0.14.2 → 0.14.4

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

@@ -0,0 +1,388 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $entity, $repository } from "../index.ts";
+import { pg } from "../providers/DatabaseTypeProvider.ts";
+
+// Helper function to parse dates from various formats
+const parseDate = (dateValue: any): Date => {
+  if (!dateValue) return new Date(0);
+  if (typeof dateValue === "string") return new Date(dateValue);
+  if (dateValue.toDate) return dateValue.toDate();
+  if (dateValue.toISOString) return new Date(dateValue.toISOString());
+  return new Date(dateValue);
+};
+
+// Test entity with timestamp fields
+const articleEntity = $entity({
+  name: "articles",
+  schema: t.object({
+    id: pg.primaryKey(),
+    title: t.string(),
+    content: t.text(),
+    status: t.string(),
+    createdAt: pg.createdAt(),
+    updatedAt: pg.updatedAt(),
+  }),
+  indexes: [
+    "createdAt",
+    "updatedAt",
+    {
+      columns: ["status", "createdAt"],
+      name: "status_created_idx",
+    },
+  ],
+});
+
+const userActivityEntity = $entity({
+  name: "user_activities",
+  schema: t.object({
+    id: pg.primaryKey(),
+    userId: t.integer(),
+    action: t.string(),
+    metadata: t.optional(t.record(t.string(), t.any())),
+    createdAt: pg.createdAt(),
+    updatedAt: t.optional(pg.updatedAt()),
+  }),
+});
+
+class TimestampTestApp {
+  articles = $repository(articleEntity);
+  activities = $repository(userActivityEntity);
+}
+
+/**
+ * Shared test function that runs on both PostgreSQL and SQLite
+ */
+const testTimestamps = async (alepha: Alepha) => {
+  const app = alepha.inject(TimestampTestApp);
+  await alepha.start();
+
+  // Test 1: createdAt should be automatically set on insert
+  const beforeCreate = new Date();
+
+  const article1 = await app.articles.create({
+    title: "First Article",
+    content: "This is the first article content",
+    status: "draft",
+  });
+
+  const afterCreate = new Date();
+
+  expect(article1.id).toBeDefined();
+  expect(article1.createdAt).toBeDefined();
+  expect(article1.updatedAt).toBeDefined();
+
+  // Parse the dates - they come as dayjs objects from DrizzleSchemaCodec
+  const createdDate = parseDate(article1.createdAt);
+  const updatedDate = parseDate(article1.updatedAt);
+
+  // createdAt should be between beforeCreate and afterCreate
+  expect(createdDate.getTime()).toBeGreaterThanOrEqual(
+    beforeCreate.getTime() - 1000,
+  ); // Allow 1s margin
+  expect(createdDate.getTime()).toBeLessThanOrEqual(
+    afterCreate.getTime() + 1000,
+  );
+
+  // Initially, updatedAt should equal createdAt
+  expect(Math.abs(createdDate.getTime() - updatedDate.getTime())).toBeLessThan(
+    1000,
+  ); // Within 1 second
+
+  // Test 2: Wait a bit and update the record
+  await new Promise((resolve) => setTimeout(resolve, 100)); // Wait 100ms
+
+  const beforeUpdate = new Date();
+
+  const updatedArticle = await app.articles.updateById(article1.id, {
+    status: "published",
+    title: "Updated First Article",
+  });
+
+  const afterUpdate = new Date();
+
+  expect(updatedArticle.title).toBe("Updated First Article");
+  expect(updatedArticle.status).toBe("published");
+
+  const newUpdatedDate = parseDate(updatedArticle.updatedAt);
+  const unchangedCreatedDate = parseDate(updatedArticle.createdAt);
+
+  // createdAt should NOT change
+  expect(unchangedCreatedDate.getTime()).toBe(createdDate.getTime());
+
+  // updatedAt should be updated and be later than createdAt
+  expect(newUpdatedDate.getTime()).toBeGreaterThan(createdDate.getTime());
+  expect(newUpdatedDate.getTime()).toBeGreaterThanOrEqual(
+    beforeUpdate.getTime() - 1000,
+  );
+  expect(newUpdatedDate.getTime()).toBeLessThanOrEqual(
+    afterUpdate.getTime() + 1000,
+  );
+
+  // Test 3: Create multiple articles and verify they have different timestamps
+  const articles = await Promise.all([
+    app.articles.create({
+      title: "Article 2",
+      content: "Content 2",
+      status: "draft",
+    }),
+    app.articles.create({
+      title: "Article 3",
+      content: "Content 3",
+      status: "published",
+    }),
+    app.articles.create({
+      title: "Article 4",
+      content: "Content 4",
+      status: "archived",
+    }),
+  ]);
+
+  // All should have createdAt and updatedAt
+  for (const article of articles) {
+    expect(article.createdAt).toBeDefined();
+    expect(article.updatedAt).toBeDefined();
+  }
+
+  // Test 4: Query using createdAt ordering
+  const sortedByCreated = await app.articles.findMany({
+    orderBy: { column: "createdAt", direction: "asc" },
+  });
+
+  // First article should be article1 (created first)
+  expect(sortedByCreated[0].id).toBe(article1.id);
+
+  // Verify the order is correct
+  for (let i = 1; i < sortedByCreated.length; i++) {
+    const prevDate = parseDate(sortedByCreated[i - 1].createdAt);
+    const currDate = parseDate(sortedByCreated[i].createdAt);
+    expect(currDate.getTime()).toBeGreaterThanOrEqual(prevDate.getTime());
+  }
+
+  // Test 5: Query with createdAt filters
+  // Use the actual createdAt value from the first article (already a Dayjs object)
+  const recentArticles = await app.articles.findMany({
+    where: {
+      createdAt: {
+        gte: article1.createdAt as any, // Cast to any since it's actually compatible at runtime
+      },
+    },
+  });
+
+  expect(recentArticles.length).toBeGreaterThan(0);
+  expect(recentArticles.some((a) => a.id === article1.id)).toBe(true);
+
+  // Test 6: Test with user activities (optional updatedAt)
+  const activity = await app.activities.create({
+    userId: 1,
+    action: "login",
+    metadata: { ip: "192.168.1.1", browser: "Chrome" },
+  });
+
+  expect(activity.createdAt).toBeDefined();
+  // updatedAt is optional, might be null or undefined initially
+
+  // Test 7: Batch operations should maintain timestamps
+  const batchArticles = await Promise.all([
+    app.articles.create({
+      title: "Batch 1",
+      content: "Batch content 1",
+      status: "draft",
+    }),
+    app.articles.create({
+      title: "Batch 2",
+      content: "Batch content 2",
+      status: "draft",
+    }),
+  ]);
+
+  // Update them all at once
+  await new Promise((resolve) => setTimeout(resolve, 100)); // Wait 100ms
+
+  const batchUpdates = await Promise.all(
+    batchArticles.map((article) =>
+      app.articles.updateById(article.id, {
+        status: "published",
+      }),
+    ),
+  );
+
+  // All should have updated timestamps
+  for (const updated of batchUpdates) {
+    const createdTime = parseDate(updated.createdAt).getTime();
+    const updatedTime = parseDate(updated.updatedAt).getTime();
+    expect(updatedTime).toBeGreaterThan(createdTime);
+  }
+
+  // Test 8: Query using composite index with timestamps
+  const statusCreatedQuery = await app.articles.findMany({
+    where: {
+      status: { eq: "published" },
+    },
+    orderBy: "createdAt",
+  });
+
+  expect(statusCreatedQuery.length).toBeGreaterThan(0);
+  expect(statusCreatedQuery.every((a) => a.status === "published")).toBe(true);
+
+  // Clean up
+  await app.articles.clear({ force: true });
+  await app.activities.clear({ force: true });
+};
+
+describe("Timestamp Fields (createdAt/updatedAt)", () => {
+  it("should handle timestamps correctly in PostgreSQL", async () => {
+    await testTimestamps(Alepha.create());
+  });
+
+  it("should handle timestamps correctly in SQLite", async () => {
+    await testTimestamps(
+      Alepha.create({
+        env: {
+          DATABASE_URL: "sqlite://:memory:",
+        },
+      }),
+    );
+  });
+
+  it("should create proper indexes on timestamp fields", async () => {
+    const alepha = Alepha.create();
+    const app = alepha.inject(TimestampTestApp);
+    await alepha.start();
+
+    // Create some test data
+    const article = await app.articles.create({
+      title: "Index Test Article",
+      content: "Testing indexes on timestamp fields",
+      status: "draft",
+    });
+
+    // Query using the createdAt index - use range query instead of exact match
+    // due to potential microsecond precision differences
+    const createdTime = parseDate(article.createdAt);
+    const startTime = new Date(createdTime.getTime() - 1000); // 1 second before
+    const endTime = new Date(createdTime.getTime() + 1000); // 1 second after
+
+    const byCreated = await app.articles.findMany({
+      where: {
+        createdAt: {
+          gte: startTime.toISOString() as any,
+          lte: endTime.toISOString() as any,
+        },
+      },
+    });
+
+    expect(byCreated.length).toBeGreaterThan(0);
+    expect(byCreated.some((a) => a.id === article.id)).toBe(true);
+
+    // Query using the composite index
+    const byStatusAndCreated = await app.articles.findMany({
+      where: {
+        status: { eq: "draft" },
+        createdAt: { gte: startTime.toISOString() as any },
+      },
+    });
+
+    expect(byStatusAndCreated.length).toBeGreaterThan(0);
+    expect(byStatusAndCreated.some((a) => a.id === article.id)).toBe(true);
+
+    await app.articles.clear({ force: true });
+  });
+
+  it("should handle timestamps with different formats", async () => {
+    // Test entity with custom timestamp configuration
+    const eventEntity = $entity({
+      name: "events",
+      schema: t.object({
+        id: pg.primaryKey(),
+        name: t.string(),
+        startTime: pg.createdAt(),
+        endTime: t.optional(pg.updatedAt()),
+        scheduledAt: t.string(), // Regular string field for ISO date
+      }),
+    });
+
+    class EventApp {
+      events = $repository(eventEntity);
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(EventApp);
+    await alepha.start();
+
+    const now = new Date();
+    const event = await app.events.create({
+      name: "Test Event",
+      scheduledAt: now.toISOString(),
+    });
+
+    expect(event.startTime).toBeDefined();
+    expect(event.scheduledAt).toBeDefined();
+
+    // startTime should be auto-generated
+    const startTime = parseDate(event.startTime);
+    expect(startTime).toBeInstanceOf(Date);
+    expect(startTime.getTime()).toBeGreaterThan(0);
+
+    // scheduledAt should match what we provided
+    expect(event.scheduledAt).toBe(now.toISOString());
+
+    await app.events.clear({ force: true });
+  });
+
+  it("should handle bulk inserts with timestamps", async () => {
+    const alepha = Alepha.create();
+    const app = alepha.inject(TimestampTestApp);
+    await alepha.start();
+
+    const beforeBulk = new Date();
+
+    // Create multiple articles at once
+    const articles = await Promise.all(
+      Array.from({ length: 10 }, (_, i) =>
+        app.articles.create({
+          title: `Bulk Article ${i}`,
+          content: `Content for article ${i}`,
+          status: i % 2 === 0 ? "draft" : "published",
+        }),
+      ),
+    );
+
+    const afterBulk = new Date();
+
+    expect(articles).toHaveLength(10);
+
+    // All should have timestamps within the expected range
+    for (const article of articles) {
+      const created = parseDate(article.createdAt);
+      const updated = parseDate(article.updatedAt);
+
+      expect(created.getTime()).toBeGreaterThanOrEqual(
+        beforeBulk.getTime() - 1000,
+      );
+      expect(created.getTime()).toBeLessThanOrEqual(afterBulk.getTime() + 1000);
+      expect(Math.abs(created.getTime() - updated.getTime())).toBeLessThan(
+        1000,
+      );
+    }
+
+    // Query and verify ordering
+    const ordered = await app.articles.findMany({
+      orderBy: [
+        { column: "createdAt", direction: "asc" },
+        { column: "id", direction: "asc" },
+      ],
+    });
+
+    expect(ordered).toHaveLength(10);
+
+    // Verify chronological order
+    for (let i = 1; i < ordered.length; i++) {
+      const prev = parseDate(ordered[i - 1].createdAt);
+      const curr = parseDate(ordered[i].createdAt);
+      expect(curr.getTime()).toBeGreaterThanOrEqual(prev.getTime());
+    }
+
+    await app.articles.clear({ force: true });
+  });
+});

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

@@ -0,0 +1,183 @@
+import { Alepha, t } from "alepha";
+import { test } from "vitest";
+import { $entity, $repository, pg } from "../index.ts";
+
+const TestEntity = $entity({
+  name: "test_validation",
+  schema: t.object({
+    id: pg.primaryKey(),
+    createdAt: pg.createdAt(),
+    updatedAt: pg.updatedAt(),
+    name: t.text(),
+    age: t.number(),
+    status: t.text(),
+  }),
+});
+
+class App {
+  items = $repository(TestEntity);
+}
+
+test("between operator validation - requires exactly 2 values", async ({
+  expect,
+}) => {
+  const alepha = Alepha.create();
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const repository = app.items;
+
+  // Insert test data
+  await repository.create({ name: "Item 1", age: 10, status: "active" });
+  await repository.create({ name: "Item 2", age: 20, status: "active" });
+  await repository.create({ name: "Item 3", age: 30, status: "active" });
+
+  // Test 1: Valid between with exactly 2 values should work
+  const result1 = await repository.findMany({
+    where: { age: { between: [15, 25] } },
+  });
+  expect(result1).toHaveLength(1);
+  expect(result1[0].name).toBe("Item 2");
+
+  // Test 2: Empty array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { age: { between: [] as any } },
+    });
+  }).rejects.toThrow("between operator requires exactly 2 values [min, max]");
+
+  // Test 3: Single value should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { age: { between: [15] as any } },
+    });
+  }).rejects.toThrow("between operator requires exactly 2 values [min, max]");
+
+  // Test 4: More than 2 values should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { age: { between: [15, 25, 35] as any } },
+    });
+  }).rejects.toThrow("between operator requires exactly 2 values [min, max]");
+
+  // Test 5: Non-array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { age: { between: 15 as any } },
+    });
+  }).rejects.toThrow("between operator requires exactly 2 values [min, max]");
+});
+
+test("notBetween operator validation - requires exactly 2 values", async ({
+  expect,
+}) => {
+  const alepha = Alepha.create();
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const repository = app.items;
+
+  // Insert test data
+  await repository.create({ name: "Item 1", age: 10, status: "active" });
+  await repository.create({ name: "Item 2", age: 20, status: "active" });
+  await repository.create({ name: "Item 3", age: 30, status: "active" });
+
+  // Test 1: Valid notBetween with exactly 2 values should work
+  const result1 = await repository.findMany({
+    where: { age: { notBetween: [15, 25] } },
+    orderBy: { column: "age", direction: "asc" },
+  });
+  expect(result1).toHaveLength(2);
+  expect(result1.map((r: any) => r.name)).toEqual(["Item 1", "Item 3"]);
+
+  // Test 2: Empty array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { age: { notBetween: [] as any } },
+    });
+  }).rejects.toThrow(
+    "notBetween operator requires exactly 2 values [min, max]",
+  );
+
+  // Test 3: Single value should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { age: { notBetween: [15] as any } },
+    });
+  }).rejects.toThrow(
+    "notBetween operator requires exactly 2 values [min, max]",
+  );
+});
+
+test("inArray operator validation - requires at least one value", async ({
+  expect,
+}) => {
+  const alepha = Alepha.create();
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const repository = app.items;
+
+  // Insert test data
+  await repository.create({ name: "Item 1", age: 10, status: "active" });
+  await repository.create({ name: "Item 2", age: 20, status: "pending" });
+  await repository.create({ name: "Item 3", age: 30, status: "inactive" });
+
+  // Test 1: Valid inArray should work
+  const result1 = await repository.findMany({
+    where: { status: { inArray: ["active", "pending"] } },
+    orderBy: { column: "age", direction: "asc" },
+  });
+  expect(result1).toHaveLength(2);
+  expect(result1.map((r: any) => r.status)).toEqual(["active", "pending"]);
+
+  // Test 2: Empty array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { status: { inArray: [] } },
+    });
+  }).rejects.toThrow("inArray operator requires at least one value");
+
+  // Test 3: Non-array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { status: { inArray: "active" as any } },
+    });
+  }).rejects.toThrow("inArray operator requires at least one value");
+});
+
+test("notInArray operator validation - requires at least one value", async ({
+  expect,
+}) => {
+  const alepha = Alepha.create();
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const repository = app.items;
+
+  // Insert test data
+  await repository.create({ name: "Item 1", age: 10, status: "active" });
+  await repository.create({ name: "Item 2", age: 20, status: "pending" });
+  await repository.create({ name: "Item 3", age: 30, status: "inactive" });
+
+  // Test 1: Valid notInArray should work
+  const result1 = await repository.findMany({
+    where: { status: { notInArray: ["active", "pending"] } },
+  });
+  expect(result1).toHaveLength(1);
+  expect(result1[0].status).toBe("inactive");
+
+  // Test 2: Empty array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { status: { notInArray: [] } },
+    });
+  }).rejects.toThrow("notInArray operator requires at least one value");
+
+  // Test 3: Non-array should throw
+  await expect(async () => {
+    await repository.findMany({
+      where: { status: { notInArray: "active" as any } },
+    });
+  }).rejects.toThrow("notInArray operator requires at least one value");
+});

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

@@ -0,0 +1,64 @@
+import { $inject, Alepha, t } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { describe, expect, it } from "vitest";
+import { DbVersionMismatchError } from "../errors/DbVersionMismatchError.ts";
+import { $entity, $repository, pg, type TransactionContext } from "../index.ts";
+
+class A {
+  dt = $inject(DateTimeProvider);
+
+  repository = $repository(
+    $entity({
+      name: "a",
+      schema: t.object({
+        id: pg.primaryKey(),
+        counter: t.integer(),
+        __v: pg.version(),
+      }),
+    }),
+  );
+
+  incFn = async (
+    id: number,
+    val: number,
+    waitMs = 0,
+    tx?: TransactionContext,
+  ) => {
+    const { counter } = await this.repository.findById(id, {
+      tx,
+    });
+
+    if (waitMs) {
+      await this.dt.wait(waitMs);
+    }
+
+    return await this.repository.updateById(
+      id,
+      {
+        counter: counter + val,
+      },
+      { tx },
+    );
+  };
+}
+
+describe("version", () => {
+  it("should detect version mismatch on concurrent updates", async () => {
+    const alepha = Alepha.create();
+    const app = alepha.inject(A);
+    await alepha.start();
+
+    const { id } = await app.repository.create({ counter: 0 });
+    const r1 = await app.repository.findById(id);
+    const r2 = await app.repository.findById(id);
+
+    r1.counter += 1;
+    r2.counter += 1;
+
+    await app.repository.save(r1);
+
+    await expect(() => app.repository.save(r2)).rejects.toThrow(
+      new DbVersionMismatchError("a", id),
+    );
+  });
+});