alepha 0.22.0 → 0.24.0

package/src/mcp/transports/StreamableHttpMcpTransport.ts

@@ -1,4 +1,4 @@
-import { $atom, $inject, $state, t } from "alepha";
+import { $atom, $inject, $state, z } from "alepha";
 import { $logger } from "alepha/logger";
 import { $route } from "alepha/server";
 import {
@@ -15,12 +15,12 @@ import { McpServerProvider } from "../providers/McpServerProvider.ts";
 export const mcpStreamableHttpOptions = $atom({
   name: "alepha.mcp.streamableHttp.options",
   description: "Configuration options for the MCP Streamable HTTP transport.",
-  schema: t.object({
+  schema: z.object({
     /**
      * Path for the MCP endpoint. Single endpoint for both requests and
      * (optional) server-streamed responses, per spec 2025-03-26+.
      */
-    path: t.text({ default: "/mcp" }),
+    path: z.text({ default: "/mcp" }),
     /**
      * Allow-list of `Origin` header values accepted on incoming requests.
      * Empty array (default) means "allow any". When set, browser-originated
@@ -31,7 +31,7 @@ export const mcpStreamableHttpOptions = $atom({
      *
      * Spec 2025-11-25, PR #1439.
      */
-    allowedOrigins: t.array(t.text(), { default: [] }),
+    allowedOrigins: z.array(z.text()).default([]),
     /**
      * When true, an unauthenticated POST to the MCP endpoint is rejected
      * with `401 Unauthorized` and an RFC 9728 `WWW-Authenticate` challenge
@@ -43,14 +43,14 @@ export const mcpStreamableHttpOptions = $atom({
      *
      * @default false
      */
-    requireAuth: t.boolean({ default: false }),
+    requireAuth: z.boolean().default(false),
     /**
      * Path of the RFC 9728 protected-resource metadata document, advertised
      * (as an absolute URL, resolved against the request origin) in the
      * `WWW-Authenticate` challenge emitted when {@link requireAuth} rejects
      * a request.
      */
-    resourceMetadataPath: t.text({
+    resourceMetadataPath: z.text({
       default: "/.well-known/oauth-protected-resource",
     }),
   }),
@@ -142,7 +142,7 @@ export class StreamableHttpMcpTransport {
     method: "POST",
     path: this.options.path,
     schema: {
-      body: t.json(),
+      body: z.json(),
     },
     handler: async (request) => {
       try {

package/src/orm/__tests__/$repository-tests.ts

@@ -1,4 +1,4 @@
-import { $hook, type Alepha, type Static, t } from "alepha";
+import { $hook, type Alepha, type Static, z } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { expect } from "vitest";
 import { DbEntityNotFoundError } from "../core/errors/DbEntityNotFoundError.ts";
@@ -125,15 +125,15 @@ class CrudApp {
   users = $repository(
     $entity({
       name: "users",
-      schema: t.object({
+      schema: z.object({
         id: db.primaryKey(),
         createdAt: db.createdAt(),
         updatedAt: db.updatedAt(),
-        name: t.text(),
-        profile: t.object({
-          age: t.number(),
+        name: z.text(),
+        profile: z.object({
+          age: z.number(),
         }),
-        role: db.default(t.text(), "user"),
+        role: db.default(z.text(), "user"),
       }),
     }),
   );
@@ -419,10 +419,10 @@ class HooksApp {
   users = $repository(
     $entity({
       name: "users",
-      schema: t.object({
+      schema: z.object({
         id: db.primaryKey(),
-        name: t.text(),
-        email: t.text(),
+        name: z.text(),
+        email: z.text(),
       }),
     }),
   );
@@ -947,9 +947,9 @@ export const testPaginationSort = async (alepha: Alepha) => {
 
 const dummyEntity = $entity({
   name: "dummies",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    name: t.optional(t.text()),
+    name: z.text().optional(),
   }),
 });
 
@@ -1026,9 +1026,9 @@ export const testTransactionThrowsWhenUnsupported = async (alepha: Alepha) => {
 
 const customPkEntity = $entity({
   name: "custom_pk_items",
-  schema: t.object({
-    code: db.primaryKey(t.uuid()),
-    label: t.text(),
+  schema: z.object({
+    code: db.primaryKey(z.uuid()),
+    label: z.text(),
   }),
 });
 
@@ -1057,13 +1057,13 @@ export const testSaveWithCustomPrimaryKey = async (alepha: Alepha) => {
 
 const productEntity = $entity({
   name: "products",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
-    sku: t.text(),
-    name: t.text(),
-    price: t.number(),
+    sku: z.text(),
+    name: z.text(),
+    price: z.number(),
   }),
   indexes: [{ column: "sku", unique: true }],
 });
@@ -1203,9 +1203,9 @@ export const testUpsert = async (alepha: Alepha) => {
 // testSerialIdOperations
 // ============================================================================
 
-const serialTestSchema = t.object({
+const serialTestSchema = z.object({
   id: db.primaryKey(),
-  name: t.text(),
+  name: z.text(),
 });
 
 const serialTestEntity = $entity({
@@ -1241,9 +1241,9 @@ export const testSerialIdOperations = async (alepha: Alepha) => {
 // testUuidIdOperations
 // ============================================================================
 
-const uuidSchema = t.object({
+const uuidSchema = z.object({
   uuid: db.uuidPrimaryKey(),
-  name: t.text(),
+  name: z.text(),
 });
 
 const uuidEntity = $entity({
@@ -1260,7 +1260,13 @@ export const testUuidIdOperations = async (alepha: Alepha) => {
   await alepha.start();
 
   expect(app.repository.id.key).toEqual("uuid");
-  expect(app.repository.id.type).toEqual(db.uuidPrimaryKey());
+  // The id column is a uuid primary key. We assert the introspectable shape
+  // rather than deep-equaling the schema object: zod lazily installs an own
+  // `meta` property on a schema the first time `.meta()` is read (which the ORM
+  // does while building columns), so two structurally-identical uuid schemas no
+  // longer compare equal by reference/own-keys.
+  expect(z.schema.format(app.repository.id.type)).toEqual("uuid");
+  expect(z.schema.format(db.uuidPrimaryKey())).toEqual("uuid");
 
   const it = await app.repository.create({ name: "test" });
 
@@ -1279,10 +1285,10 @@ export const testUuidIdOperations = async (alepha: Alepha) => {
 // testMultipleOperators
 // ============================================================================
 
-const rangeSchema = t.object({
+const rangeSchema = z.object({
   id: db.primaryKey(),
-  name: t.text(),
-  age: t.number(),
+  name: z.text(),
+  age: z.number(),
 });
 
 const rangeEntity = $entity({
@@ -1653,3 +1659,103 @@ export const testPagination = async (alepha: Alepha) => {
   // Clean up
   await app.users.clear({ force: true });
 };
+
+// ============================================================================
+// testPaginationWithQueryLimit — `paginate` reads its page size from
+// `query.limit` as well as `pagination.size`. The `+1` sentinel row that
+// `createPagination` uses to detect a next page must survive either way;
+// spreading `query` over the computed `limit + 1` used to erase it, which made
+// `isLast` always true for callers passing `query.limit`.
+// ============================================================================
+
+export const testPaginationWithQueryLimit = async (alepha: Alepha) => {
+  const app = alepha.inject(PaginationApp);
+  await alepha.start();
+
+  for (let i = 1; i <= 25; i++) {
+    await app.users.create({
+      name: `User ${i}`,
+      profile: { age: 20 + i },
+      role: i % 2 === 0 ? "admin" : "user",
+    });
+  }
+
+  // First page: 25 rows, 10 per page => there IS a next page.
+  const first = await app.users.paginate({ page: 0 }, { limit: 10 });
+
+  expect(first.content.length).toBe(10);
+  expect(first.page.size).toBe(10);
+  expect(first.page.offset).toBe(0);
+  expect(first.page.isFirst).toBe(true);
+  expect(first.page.isLast).toBe(false);
+
+  // Middle page: still not the last one.
+  const middle = await app.users.paginate({ page: 1 }, { limit: 10 });
+
+  expect(middle.content.length).toBe(10);
+  expect(middle.page.offset).toBe(10);
+  expect(middle.page.isFirst).toBe(false);
+  expect(middle.page.isLast).toBe(false);
+
+  // Final page: 5 remaining rows, no sentinel => last.
+  const last = await app.users.paginate({ page: 2 }, { limit: 10 });
+
+  expect(last.content.length).toBe(5);
+  expect(last.page.offset).toBe(20);
+  expect(last.page.isLast).toBe(true);
+
+  // Clean up
+  await app.users.clear({ force: true });
+};
+
+// ============================================================================
+// testConditionsWithSiblings — `or`/`and` keys must AND-combine with their
+// sibling field conditions, not short-circuit the whole where (the early
+// `return or(...)` in QueryManager used to DROP every other key).
+// ============================================================================
+
+const orSiblingsEntity = $entity({
+  name: "test_or_siblings",
+  schema: z.object({
+    id: db.primaryKey(),
+    name: z.text(),
+    age: z.number(),
+  }),
+});
+
+class ConditionsWithSiblingsApp {
+  repository = $repository(orSiblingsEntity);
+}
+
+export const testConditionsWithSiblings = async (alepha: Alepha) => {
+  const app = alepha.inject(ConditionsWithSiblingsApp);
+  await alepha.start();
+
+  await app.repository.create({ name: "Alice", age: 20 });
+  await app.repository.create({ name: "Bob", age: 25 });
+  await app.repository.create({ name: "Alice", age: 40 });
+  await app.repository.create({ name: "Eve", age: 40 });
+
+  // `or` next to a field condition: name must still constrain the result.
+  const orResults = await app.repository.findMany({
+    where: {
+      name: { eq: "Alice" },
+      or: [{ age: { lt: 22 } }, { age: { gt: 35 } }],
+    },
+  });
+  expect(orResults).toHaveLength(2);
+  expect(orResults.every((r) => r.name === "Alice")).toBe(true);
+
+  // `and` next to a field condition behaves the same way.
+  const andResults = await app.repository.findMany({
+    where: {
+      name: { eq: "Alice" },
+      and: [{ age: { gte: 18 } }, { age: { lte: 25 } }],
+    },
+  });
+  expect(andResults).toHaveLength(1);
+  expect(andResults[0].age).toBe(20);
+
+  // Clean up
+  await app.repository.clear({ force: true });
+};

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

@@ -4,11 +4,13 @@ import { AlephaOrmPostgres } from "../postgres/index.ts";
 import {
   testAllTypes,
   testBasicCrud,
+  testConditionsWithSiblings,
   testCrudWithTimestamps,
   testMultipleOperators,
   testOrderByModes,
   testPagination,
   testPaginationSort,
+  testPaginationWithQueryLimit,
   testPgAttr,
   testRepositoryHooks,
   testSaveWithCustomPrimaryKey,
@@ -64,6 +66,17 @@ describe("$repository", () => {
     });
   });
 
+  describe("or/and with sibling conditions", () => {
+    it("should AND-combine or/and with sibling field conditions (sqlite)", async () => {
+      await testConditionsWithSiblings(
+        Alepha.create({ env: { DATABASE_URL: "sqlite://:memory:" } }),
+      );
+    });
+    it("should AND-combine or/and with sibling field conditions (postgres)", async () => {
+      await testConditionsWithSiblings(Alepha.create().with(AlephaOrmPostgres));
+    });
+  });
+
   describe("orderBy", () => {
     it("should support all 3 orderBy modes (sqlite)", async () => {
       await testOrderByModes(
@@ -173,5 +186,15 @@ describe("$repository", () => {
     it("should return correct pagination metadata (postgres)", async () => {
       await testPagination(Alepha.create().with(AlephaOrmPostgres));
     });
+    it("should detect the next page when size comes from query.limit (sqlite)", async () => {
+      await testPaginationWithQueryLimit(
+        Alepha.create({ env: { DATABASE_URL: "sqlite://:memory:" } }),
+      );
+    });
+    it("should detect the next page when size comes from query.limit (postgres)", async () => {
+      await testPaginationWithQueryLimit(
+        Alepha.create().with(AlephaOrmPostgres),
+      );
+    });
   });
 });

package/src/orm/__tests__/$transactional-tests.ts

@@ -1,4 +1,4 @@
-import { $inject, $pipeline, type Alepha, createMiddleware, t } from "alepha";
+import { $inject, $pipeline, type Alepha, createMiddleware, z } from "alepha";
 import { expect } from "vitest";
 import {
   $entity,
@@ -10,9 +10,9 @@ import {
 
 const item = $entity({
   name: "tx_mw_item",
-  schema: t.object({
-    id: db.primaryKey(t.integer(), {}, { mode: "byDefault" }),
-    name: t.text(),
+  schema: z.object({
+    id: db.primaryKey(z.integer(), {}, { mode: "byDefault" }),
+    name: z.text(),
   }),
 });
 

package/src/orm/__tests__/ModelBuilder-tests.ts

@@ -1,5 +1,5 @@
 import type { Alepha } from "alepha";
-import { t } from "alepha";
+import { z } from "alepha";
 import { sql } from "drizzle-orm";
 import { expect } from "vitest";
 import { $entity, $repository } from "../core/index.ts";
@@ -11,10 +11,10 @@ import { db } from "../core/providers/DatabaseTypeProvider.ts";
 
 const roleEntity = $entity({
   name: "roles",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    name: t.string(),
-    description: t.optional(t.string()),
+    name: z.string(),
+    description: z.string().optional(),
   }),
   indexes: ["name"],
   constraints: [
@@ -28,13 +28,13 @@ const roleEntity = $entity({
 
 const userEntity = $entity({
   name: "users",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    email: t.email(),
-    username: t.string(),
-    age: t.integer(),
-    roleId: t.integer(),
-    status: t.string(),
+    email: z.email(),
+    username: z.string(),
+    age: z.integer(),
+    roleId: z.integer(),
+    status: z.string(),
   }),
   indexes: [
     "email",
@@ -70,14 +70,14 @@ const userEntity = $entity({
 
 const postEntity = $entity({
   name: "posts",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    userId: t.integer(),
-    title: t.string(),
-    content: t.text(),
-    published: t.boolean(),
-    views: t.integer(),
-    tags: t.optional(t.array(t.string())),
+    userId: z.integer(),
+    title: z.string(),
+    content: z.text(),
+    published: z.boolean(),
+    views: z.integer(),
+    tags: z.array(z.string()).optional(),
   }),
   indexes: [
     "title",
@@ -309,9 +309,9 @@ export const testModelBuilderFeatures = async (alepha: Alepha) => {
 export const testCustomConfig = async (alepha: Alepha) => {
   const customEntity = $entity({
     name: "custom_table",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      data: t.string(),
+      data: z.string(),
     }),
     config: (self) => {
       return [];
@@ -341,9 +341,9 @@ export const testCustomConfig = async (alepha: Alepha) => {
 export const testComplexRelationships = async (alepha: Alepha) => {
   const categoryEntity = $entity({
     name: "categories",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.string(),
+      name: z.string(),
     }),
     indexes: [
       {
@@ -355,11 +355,11 @@ export const testComplexRelationships = async (alepha: Alepha) => {
 
   const productEntity = $entity({
     name: "products",
-    schema: t.object({
+    schema: z.object({
       id: db.primaryKey(),
-      name: t.string(),
-      categoryId: t.integer(),
-      price: t.number(),
+      name: z.string(),
+      categoryId: z.integer(),
+      price: z.number(),
     }),
     indexes: [
       "name",
@@ -429,10 +429,10 @@ export const testComplexRelationships = async (alepha: Alepha) => {
 
 const usersWithLowerIndex = $entity({
   name: "users_lower",
-  schema: t.object({
+  schema: z.object({
     id: db.primaryKey(),
-    realm: t.text(),
-    username: t.text(),
+    realm: z.text(),
+    username: z.text(),
   }),
   indexes: [
     {