alepha 0.18.2 → 0.18.3

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

@@ -0,0 +1,492 @@
+import { type Alepha, AlephaError, t } from "alepha";
+import { sql } from "drizzle-orm";
+import { expect } from "vitest";
+import { PG_GENERATED } from "../core/constants/PG_SYMBOLS.ts";
+import { $entity, $repository, $view, db, pgAttr } from "../core/index.ts";
+
+// ============================================================================
+// Shared entity definitions
+// ============================================================================
+
+const orderEntity = $entity({
+  name: "orders",
+  schema: t.object({
+    id: db.primaryKey(),
+    category: t.text(),
+    amount: t.number(),
+    status: t.text(),
+  }),
+});
+
+// ============================================================================
+// Feature 1: Partial Indexes
+// ============================================================================
+
+export const testPartialIndex = async (alepha: Alepha) => {
+  const entity = $entity({
+    name: "items_partial_idx",
+    schema: t.object({
+      id: db.primaryKey(),
+      email: t.text(),
+      active: t.boolean(),
+    }),
+    indexes: [
+      {
+        column: "email",
+        unique: true,
+        where: sql`active = true`,
+      },
+    ],
+  });
+
+  class App {
+    repo = $repository(entity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // Create an active item — unique constraint applies
+  const a = await app.repo.create({ email: "alice@test.com", active: true });
+  expect(a.email).toBe("alice@test.com");
+
+  // Deactivate it — no longer covered by partial index
+  await app.repo.updateById(a.id, { active: false });
+
+  // Insert same email as active — allowed because first one is inactive
+  const b = await app.repo.create({ email: "alice@test.com", active: true });
+  expect(b.email).toBe("alice@test.com");
+  expect(b.id).not.toBe(a.id);
+};
+
+export const testPartialCompositeIndex = async (alepha: Alepha) => {
+  const entity = $entity({
+    name: "items_partial_comp_idx",
+    schema: t.object({
+      id: db.primaryKey(),
+      category: t.text(),
+      name: t.text(),
+      active: t.boolean(),
+    }),
+    indexes: [
+      {
+        columns: ["category", "name"],
+        unique: true,
+        where: sql`active = true`,
+      },
+    ],
+  });
+
+  class App {
+    repo = $repository(entity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.repo.create({ category: "A", name: "foo", active: true });
+
+  // Same category+name but inactive — allowed by partial index
+  await app.repo.create({ category: "A", name: "foo", active: false });
+
+  const all = await app.repo.findMany();
+  expect(all).toHaveLength(2);
+};
+
+// ============================================================================
+// Feature 2: Subqueries (exists / notExists)
+// ============================================================================
+
+export const testExistsSubquery = async (alepha: Alepha) => {
+  const parentEntity = $entity({
+    name: "parents_exist",
+    schema: t.object({
+      id: db.primaryKey(),
+      name: t.text(),
+    }),
+  });
+
+  const childEntity = $entity({
+    name: "children_exist",
+    schema: t.object({
+      id: db.primaryKey(),
+      parentId: t.integer(),
+      label: t.text(),
+    }),
+  });
+
+  class App {
+    parents = $repository(parentEntity);
+    children = $repository(childEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const p1 = await app.parents.create({ name: "P1" });
+  const p2 = await app.parents.create({ name: "P2" });
+  await app.children.create({ parentId: p1.id, label: "C1" });
+
+  // parents that have at least one child
+  const withChildren = await app.parents.findMany({
+    where: {
+      exists: sql`(SELECT 1 FROM children_exist WHERE children_exist.parent_id = parents_exist.id)`,
+    },
+  });
+  expect(withChildren).toHaveLength(1);
+  expect(withChildren[0].name).toBe("P1");
+
+  // parents that have NO children
+  const withoutChildren = await app.parents.findMany({
+    where: {
+      notExists: sql`(SELECT 1 FROM children_exist WHERE children_exist.parent_id = parents_exist.id)`,
+    },
+  });
+  expect(withoutChildren).toHaveLength(1);
+  expect(withoutChildren[0].name).toBe("P2");
+};
+
+// ============================================================================
+// Feature 4: Aggregate Functions
+// ============================================================================
+
+export const testAggregateBasic = async (alepha: Alepha) => {
+  class App {
+    orders = $repository(orderEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.orders.createMany([
+    { category: "A", amount: 100, status: "paid" },
+    { category: "A", amount: 200, status: "paid" },
+    { category: "B", amount: 50, status: "paid" },
+    { category: "B", amount: 150, status: "pending" },
+  ]);
+
+  // Basic grouped aggregation
+  const result = await app.orders.aggregate({
+    select: { category: true, amount: { sum: true, avg: true } },
+    groupBy: ["category"],
+    orderBy: "category",
+  });
+
+  expect(result).toHaveLength(2);
+  expect(result[0].category).toBe("A");
+  expect(result[0].amount.sum).toBe(300);
+  expect(result[0].amount.avg).toBe(150);
+  expect(result[1].category).toBe("B");
+  expect(result[1].amount.sum).toBe(200);
+};
+
+export const testAggregateMinMaxCount = async (alepha: Alepha) => {
+  class App {
+    orders = $repository(orderEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.orders.createMany([
+    { category: "X", amount: 10, status: "paid" },
+    { category: "X", amount: 30, status: "paid" },
+    { category: "X", amount: 50, status: "paid" },
+  ]);
+
+  const result = await app.orders.aggregate({
+    select: {
+      category: true,
+      amount: { min: true, max: true, count: true },
+    },
+    groupBy: ["category"],
+  });
+
+  expect(result).toHaveLength(1);
+  expect(result[0].amount.min).toBe(10);
+  expect(result[0].amount.max).toBe(50);
+  expect(result[0].amount.count).toBe(3);
+};
+
+export const testAggregateHaving = async (alepha: Alepha) => {
+  class App {
+    orders = $repository(orderEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.orders.createMany([
+    { category: "A", amount: 10, status: "paid" },
+    { category: "A", amount: 20, status: "paid" },
+    { category: "B", amount: 500, status: "paid" },
+    { category: "B", amount: 600, status: "paid" },
+  ]);
+
+  // Only groups where sum > 100
+  const result = await app.orders.aggregate({
+    select: { category: true, amount: { sum: true } },
+    groupBy: ["category"],
+    having: { amount: { sum: { gt: 100 } } },
+  });
+
+  expect(result).toHaveLength(1);
+  expect(result[0].category).toBe("B");
+  expect(result[0].amount.sum).toBe(1100);
+};
+
+export const testAggregateOrderByDotNotation = async (alepha: Alepha) => {
+  class App {
+    orders = $repository(orderEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.orders.createMany([
+    { category: "A", amount: 500, status: "paid" },
+    { category: "B", amount: 100, status: "paid" },
+    { category: "C", amount: 300, status: "paid" },
+  ]);
+
+  const result = await app.orders.aggregate({
+    select: { category: true, amount: { sum: true } },
+    groupBy: ["category"],
+    orderBy: { column: "amount.sum", direction: "desc" },
+  });
+
+  expect(result).toHaveLength(3);
+  expect(result[0].category).toBe("A");
+  expect(result[1].category).toBe("C");
+  expect(result[2].category).toBe("B");
+};
+
+// ============================================================================
+// Feature 6: Generated Columns (SQLite only — virtual)
+// ============================================================================
+
+export const testGeneratedColumnSqlite = async (alepha: Alepha) => {
+  const entity = $entity({
+    name: "generated_col",
+    schema: t.object({
+      id: db.primaryKey(),
+      firstName: t.text(),
+      lastName: t.text(),
+      fullName: pgAttr(t.text(), PG_GENERATED, {
+        expression: sql`first_name || ' ' || last_name`,
+        mode: "virtual",
+      }),
+    }),
+  });
+
+  class App {
+    repo = $repository(entity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // Insert without fullName — it's computed
+  const created = await app.repo.create({
+    firstName: "John",
+    lastName: "Doe",
+  } as any);
+
+  expect(created.fullName).toBe("John Doe");
+
+  // Verify findMany also returns the computed value
+  const all = await app.repo.findMany();
+  expect(all).toHaveLength(1);
+  expect(all[0].fullName).toBe("John Doe");
+};
+
+export const testGeneratedColumnPostgres = async (alepha: Alepha) => {
+  const entity = $entity({
+    name: "generated_col_pg",
+    schema: t.object({
+      id: db.primaryKey(),
+      firstName: t.text(),
+      lastName: t.text(),
+      fullName: pgAttr(t.text(), PG_GENERATED, {
+        expression: sql`first_name || ' ' || last_name`,
+        mode: "stored",
+      }),
+    }),
+  });
+
+  class App {
+    repo = $repository(entity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  const created = await app.repo.create({
+    firstName: "Jane",
+    lastName: "Smith",
+  } as any);
+
+  expect(created.fullName).toBe("Jane Smith");
+
+  const all = await app.repo.findMany();
+  expect(all).toHaveLength(1);
+  expect(all[0].fullName).toBe("Jane Smith");
+};
+
+export const testGeneratedColumnExcludedFromInsertSchema = async (
+  alepha: Alepha,
+) => {
+  const entity = $entity({
+    name: "generated_schema_test",
+    schema: t.object({
+      id: db.primaryKey(),
+      a: t.text(),
+      b: t.text(),
+      computed: pgAttr(t.text(), PG_GENERATED, {
+        expression: sql`a || b`,
+        mode: "virtual",
+      }),
+    }),
+  });
+
+  // Verify insertSchema does not contain generated column
+  const insertProps = Object.keys(entity.insertSchema.properties);
+  expect(insertProps).toContain("a");
+  expect(insertProps).toContain("b");
+  expect(insertProps).not.toContain("computed");
+
+  // Verify updateSchema does not contain generated column
+  const updateProps = Object.keys(entity.updateSchema.properties);
+  expect(updateProps).toContain("a");
+  expect(updateProps).toContain("b");
+  expect(updateProps).not.toContain("computed");
+};
+
+// ============================================================================
+// Feature 7: Query Caching
+// ============================================================================
+
+export const testQueryCache = async (alepha: Alepha) => {
+  class App {
+    orders = $repository(orderEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.orders.create({ category: "A", amount: 100, status: "paid" });
+
+  // First call — hits DB
+  const first = await app.orders.findMany(
+    { where: { category: { eq: "A" } } },
+    { cache: { ttl: 60_000 } },
+  );
+  expect(first).toHaveLength(1);
+
+  // Insert another — won't be in cache (cache was invalidated by write)
+  await app.orders.create({ category: "A", amount: 200, status: "paid" });
+
+  // This should hit DB again (cache was invalidated by the create above)
+  const afterInsert = await app.orders.findMany(
+    { where: { category: { eq: "A" } } },
+    { cache: { ttl: 60_000 } },
+  );
+  expect(afterInsert).toHaveLength(2);
+
+  // This should return cached result (no writes since last query)
+  const cached = await app.orders.findMany(
+    { where: { category: { eq: "A" } } },
+    { cache: { ttl: 60_000 } },
+  );
+  expect(cached).toHaveLength(2);
+};
+
+export const testQueryCacheCustomKey = async (alepha: Alepha) => {
+  class App {
+    orders = $repository(orderEntity);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await app.orders.create({ category: "A", amount: 100, status: "paid" });
+
+  // Use custom cache key
+  const result = await app.orders.findMany(
+    {},
+    { cache: { ttl: 60_000, key: "all-orders" } },
+  );
+  expect(result).toHaveLength(1);
+
+  // Same custom key returns cached result
+  const cached = await app.orders.findMany(
+    {},
+    { cache: { ttl: 60_000, key: "all-orders" } },
+  );
+  expect(cached).toHaveLength(1);
+};
+
+// ============================================================================
+// Feature 8: Database Views
+// ============================================================================
+
+export const testViewReadOnly = async (alepha: Alepha) => {
+  // Create the underlying table
+  const itemEntity = $entity({
+    name: "view_items",
+    schema: t.object({
+      id: db.primaryKey(),
+      name: t.text(),
+      price: t.number(),
+    }),
+  });
+
+  // Create a view
+  const itemView = $view({
+    name: "view_items_summary",
+    schema: t.object({
+      id: t.integer(),
+      name: t.text(),
+      price: t.number(),
+    }),
+    query: sql`SELECT id, name, price FROM view_items`,
+  });
+
+  class App {
+    items = $repository(itemEntity);
+    summary = $repository(itemView);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  // Verify the repository detects it's a view
+  expect(app.summary.isReadOnly).toBe(true);
+  expect(app.items.isReadOnly).toBe(false);
+
+  // Write operations should throw on views
+  await expect(
+    app.summary.create({ id: 1, name: "test", price: 10 } as any),
+  ).rejects.toThrow(AlephaError);
+};
+
+export const testViewRefreshThrowsForNonMaterialized = async (
+  alepha: Alepha,
+) => {
+  const view = $view({
+    name: "non_mat_view",
+    schema: t.object({
+      id: t.integer(),
+    }),
+    query: sql`SELECT 1 as id`,
+  });
+
+  class App {
+    repo = $repository(view);
+  }
+
+  const app = alepha.inject(App);
+  await alepha.start();
+
+  await expect(app.repo.refresh()).rejects.toThrow(AlephaError);
+};

package/src/orm/__tests__/orm-next.spec.ts

@@ -0,0 +1,140 @@
+import { Alepha } from "alepha";
+import { describe, it } from "vitest";
+import { AlephaOrmPostgres } from "../postgres/index.ts";
+import {
+  testAggregateBasic,
+  testAggregateHaving,
+  testAggregateMinMaxCount,
+  testAggregateOrderByDotNotation,
+  testExistsSubquery,
+  testGeneratedColumnExcludedFromInsertSchema,
+  testGeneratedColumnPostgres,
+  testGeneratedColumnSqlite,
+  testPartialCompositeIndex,
+  testPartialIndex,
+  testQueryCache,
+  testQueryCacheCustomKey,
+  testViewReadOnly,
+  testViewRefreshThrowsForNonMaterialized,
+} from "./orm-next-tests.ts";
+
+const sqlite = () =>
+  Alepha.create({ env: { DATABASE_URL: "sqlite://:memory:" } });
+const postgres = () => Alepha.create().with(AlephaOrmPostgres);
+
+// =============================================================================
+// Feature 1: Partial Indexes
+// =============================================================================
+
+describe("partial indexes", () => {
+  it("should support partial unique index (sqlite)", async () => {
+    await testPartialIndex(sqlite());
+  });
+  it("should support partial unique index (postgres)", async () => {
+    await testPartialIndex(postgres());
+  });
+  it("should support partial composite index (sqlite)", async () => {
+    await testPartialCompositeIndex(sqlite());
+  });
+  it("should support partial composite index (postgres)", async () => {
+    await testPartialCompositeIndex(postgres());
+  });
+});
+
+// =============================================================================
+// Feature 2: Subqueries (exists / notExists)
+// =============================================================================
+
+describe("subqueries", () => {
+  it("should support exists and notExists (sqlite)", async () => {
+    await testExistsSubquery(sqlite());
+  });
+  it("should support exists and notExists (postgres)", async () => {
+    await testExistsSubquery(postgres());
+  });
+});
+
+// =============================================================================
+// Feature 4: Aggregate Functions
+// =============================================================================
+
+describe("aggregates", () => {
+  it("should compute sum and avg grouped by column (sqlite)", async () => {
+    await testAggregateBasic(sqlite());
+  });
+  it("should compute sum and avg grouped by column (postgres)", async () => {
+    await testAggregateBasic(postgres());
+  });
+  it("should compute min, max, and count (sqlite)", async () => {
+    await testAggregateMinMaxCount(sqlite());
+  });
+  it("should compute min, max, and count (postgres)", async () => {
+    await testAggregateMinMaxCount(postgres());
+  });
+  it("should filter groups with having clause (sqlite)", async () => {
+    await testAggregateHaving(sqlite());
+  });
+  it("should filter groups with having clause (postgres)", async () => {
+    await testAggregateHaving(postgres());
+  });
+  it("should order by aggregate with dot notation (sqlite)", async () => {
+    await testAggregateOrderByDotNotation(sqlite());
+  });
+  it("should order by aggregate with dot notation (postgres)", async () => {
+    await testAggregateOrderByDotNotation(postgres());
+  });
+});
+
+// =============================================================================
+// Feature 6: Generated Columns
+// =============================================================================
+
+describe("generated columns", () => {
+  it("should compute virtual generated column (sqlite)", async () => {
+    await testGeneratedColumnSqlite(sqlite());
+  });
+  it("should compute stored generated column (postgres)", async () => {
+    await testGeneratedColumnPostgres(postgres());
+  });
+  it("should exclude generated columns from insert and update schemas", async () => {
+    await testGeneratedColumnExcludedFromInsertSchema(sqlite());
+  });
+});
+
+// =============================================================================
+// Feature 7: Query Caching
+// =============================================================================
+
+describe("query caching", () => {
+  it("should cache and invalidate on write (sqlite)", async () => {
+    await testQueryCache(sqlite());
+  });
+  it("should cache and invalidate on write (postgres)", async () => {
+    await testQueryCache(postgres());
+  });
+  it("should support custom cache keys (sqlite)", async () => {
+    await testQueryCacheCustomKey(sqlite());
+  });
+  it("should support custom cache keys (postgres)", async () => {
+    await testQueryCacheCustomKey(postgres());
+  });
+});
+
+// =============================================================================
+// Feature 8: Database Views
+// =============================================================================
+
+describe("database views", () => {
+  it("should block writes on view repositories (sqlite)", async () => {
+    await testViewReadOnly(sqlite());
+  });
+  it("should block writes on view repositories (postgres)", async () => {
+    await testViewReadOnly(postgres());
+  });
+  it("should throw on refresh for non-materialized view (sqlite)", async () => {
+    await testViewRefreshThrowsForNonMaterialized(sqlite());
+  });
+  it("should throw on refresh for non-materialized view (postgres)", async () => {
+    await testViewRefreshThrowsForNonMaterialized(postgres());
+  });
+});

package/src/orm/core/constants/PG_SYMBOLS.ts

@@ -1,3 +1,4 @@
+import type { SQL } from "drizzle-orm";
 import type {
   PgSequenceOptions,
   UpdateDeleteAction,
@@ -13,6 +14,7 @@ export const PG_VERSION = Symbol.for("Alepha.Postgres.Version");
 export const PG_IDENTITY = Symbol.for("Alepha.Postgres.Identity");
 export const PG_ENUM = Symbol.for("Alepha.Postgres.Enum");
 export const PG_REF = Symbol.for("Alepha.Postgres.Ref");
+export const PG_GENERATED = Symbol.for("Alepha.Postgres.Generated");
 
 /**
  * @deprecated Use `PG_IDENTITY` instead.
@@ -33,6 +35,7 @@ export type PgSymbols = {
   [PG_IDENTITY]: PgIdentityOptions;
   [PG_REF]: PgRefOptions;
   [PG_ENUM]: PgEnumOptions;
+  [PG_GENERATED]: PgGeneratedOptions;
 
   /**
    * @deprecated Use `PG_IDENTITY` instead.
@@ -53,6 +56,20 @@ export interface PgEnumOptions {
   description?: string;
 }
 
+export interface PgGeneratedOptions {
+  /**
+   * SQL expression for the generated column.
+   */
+  expression: SQL;
+
+  /**
+   * Storage mode for the generated column.
+   * - `"stored"` — value is computed on write and stored on disk (default for PostgreSQL).
+   * - `"virtual"` — value is computed on read (default for SQLite).
+   */
+  mode?: "stored" | "virtual";
+}
+
 export interface PgRefOptions {
   ref: () => {
     name: string;

package/src/orm/core/index.bun.ts

@@ -1,4 +1,4 @@
-import { $module, type Alepha, t } from "alepha";
+import { $module, type Alepha } from "alepha";
 import { AlephaDateTime } from "alepha/datetime";
 import { $entity } from "./primitives/$entity.ts";
 import { $sequence } from "./primitives/$sequence.ts";
@@ -7,6 +7,7 @@ import { BunSqliteProvider } from "./providers/drivers/BunSqliteProvider.ts";
 import { CloudflareD1Provider } from "./providers/drivers/CloudflareD1Provider.ts";
 import { DatabaseProvider } from "./providers/drivers/DatabaseProvider.ts";
 import { RepositoryProvider } from "./providers/RepositoryProvider.ts";
+import { databaseEnvSchema } from "./schemas/databaseEnvSchema.ts";
 import { PgRelationManager } from "./services/PgRelationManager.ts";
 import { QueryManager } from "./services/QueryManager.ts";
 import { Repository } from "./services/Repository.ts";
@@ -33,11 +34,7 @@ export const AlephaOrm = $module({
     QueryManager,
   ],
   register: (alepha: Alepha) => {
-    const env = alepha.parseEnv(
-      t.object({
-        DATABASE_URL: t.optional(t.text()),
-      }),
-    );
+    const env = alepha.parseEnv(databaseEnvSchema);
 
     alepha.with(DrizzleKitProvider);
     alepha.with(RepositoryProvider);