alepha 0.18.2 → 0.18.3

package/dist/orm/core/index.d.ts

@@ -32,6 +32,7 @@ declare const PG_VERSION: unique symbol;
 declare const PG_IDENTITY: unique symbol;
 declare const PG_ENUM: unique symbol;
 declare const PG_REF: unique symbol;
+declare const PG_GENERATED: unique symbol;
 /**
  * @deprecated Use `PG_IDENTITY` instead.
  */
@@ -49,6 +50,7 @@ type PgSymbols = {
   [PG_IDENTITY]: PgIdentityOptions;
   [PG_REF]: PgRefOptions;
   [PG_ENUM]: PgEnumOptions;
+  [PG_GENERATED]: PgGeneratedOptions;
   /**
    * @deprecated Use `PG_IDENTITY` instead.
    */
@@ -64,6 +66,18 @@ interface PgEnumOptions {
   name?: string;
   description?: string;
 }
+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";
+}
 interface PgRefOptions {
   ref: () => {
     name: string;
@@ -79,12 +93,15 @@ interface PgRefOptions {
 /**
  * Transforms a TObject schema for insert operations.
  * All default properties at the root level are made optional.
+ * Generated columns are excluded entirely.
  *
  * @example
- * Before: { name: string; age: number(default=0); }
+ * Before: { name: string; age: number(default=0); fullName: generated }
  * After:  { name: string; age?: number; }
  */
-type TObjectInsert<T extends TObject> = TObject<{ [K in keyof T["properties"]]: T["properties"][K] extends {
+type TObjectInsert<T extends TObject> = TObject<{ [K in keyof T["properties"] as T["properties"][K] extends {
+  [PG_GENERATED]: any;
+} ? never : K]: T["properties"][K] extends {
   [PG_DEFAULT]: any;
 } | {
   "~optional": true;
@@ -95,13 +112,15 @@ declare const insertSchema: <T extends TObject>(obj: T) => TObjectInsert<T>;
 /**
  * Transforms a TObject schema for update operations.
  * All optional properties at the root level are made nullable (i.e., `T | null`).
- * This allows an API endpoint to explicitly accept `null` to clear an optional field in the database.
+ * Generated columns are excluded entirely.
  *
  * @example
- * Before: { name?: string; age: number; }
+ * Before: { name?: string; age: number; fullName: generated }
  * After:  { name?: string | null; age: number; }
  */
-type TObjectUpdate<T extends TObject> = TObject<{ [K in keyof T["properties"]]: T["properties"][K] extends TOptional<infer U> ? TOptional<TUnion<[U, TNull]>> : T["properties"][K] }>;
+type TObjectUpdate<T extends TObject> = TObject<{ [K in keyof T["properties"] as T["properties"][K] extends {
+  [PG_GENERATED]: any;
+} ? never : K]: T["properties"][K] extends TOptional<infer U> ? TOptional<TUnion<[U, TNull]>> : T["properties"][K] }>;
 declare const updateSchema: <T extends TObject>(schema: T) => TObjectUpdate<T>;
 //#endregion
 //#region ../../src/orm/core/primitives/$entity.d.ts
@@ -153,6 +172,10 @@ interface EntityPrimitiveOptions<T extends TObject, Keys = keyof Static<T>> {
      * Custom name for the index. If not provided, generates name automatically.
      */
     name?: string;
+    /**
+     * Partial index condition. Only rows matching this SQL expression are indexed.
+     */
+    where?: SQL;
   } | {
     /**
      * Multiple columns for composite index (order matters for query optimization).
@@ -166,6 +189,10 @@ interface EntityPrimitiveOptions<T extends TObject, Keys = keyof Static<T>> {
      * Custom name for the index. If not provided, generates name automatically.
      */
     name?: string;
+    /**
+     * Partial index condition. Only rows matching this SQL expression are indexed.
+     */
+    where?: SQL;
   })[];
   /**
    * Foreign key constraints to maintain referential integrity.
@@ -265,6 +292,69 @@ type EntityColumn<T extends TObject> = {
 };
 type EntityColumns<T extends TObject> = { [key in keyof T["properties"]]: EntityColumn<T> };
 //#endregion
+//#region ../../src/orm/core/primitives/$view.d.ts
+/**
+ * Creates a database view primitive from a TypeBox schema and SQL query.
+ *
+ * Views are read-only: Repository blocks all write operations.
+ *
+ * @example
+ * ```ts
+ * import { t } from "alepha";
+ * import { $view } from "alepha/orm";
+ * import { sql } from "drizzle-orm";
+ *
+ * const userSummary = $view({
+ *   name: "user_summary",
+ *   schema: t.object({
+ *     id: t.uuid(),
+ *     fullName: t.text(),
+ *     orderCount: t.integer(),
+ *   }),
+ *   query: sql`SELECT u.id, u.first_name || ' ' || u.last_name AS full_name, COUNT(o.id) AS order_count FROM users u LEFT JOIN orders o ON o.user_id = u.id GROUP BY u.id`,
+ * });
+ *
+ * // Materialized view (PostgreSQL only)
+ * const monthlyStats = $view({
+ *   name: "monthly_stats",
+ *   schema: t.object({ ... }),
+ *   query: sql`...`,
+ *   materialized: true,
+ * });
+ * ```
+ */
+declare const $view: {
+  <TSchema extends TObject>(options: ViewPrimitiveOptions<TSchema>): ViewPrimitive<TSchema>;
+  [KIND]: typeof ViewPrimitive;
+};
+interface ViewPrimitiveOptions<T extends TObject> {
+  /**
+   * The database view name.
+   */
+  name: string;
+  /**
+   * TypeBox schema defining the view's columns.
+   */
+  schema: T;
+  /**
+   * SQL query that defines the view.
+   */
+  query: SQL;
+  /**
+   * Whether this is a materialized view (PostgreSQL only).
+   * Materialized views store results on disk and can be refreshed.
+   */
+  materialized?: boolean;
+}
+declare class ViewPrimitive<T extends TObject = TObject> {
+  readonly options: ViewPrimitiveOptions<T>;
+  readonly isView = true;
+  constructor(options: ViewPrimitiveOptions<T>);
+  get name(): string;
+  get schema(): T;
+  get materialized(): boolean;
+}
+//#endregion
 //#region ../../src/orm/core/services/ModelBuilder.d.ts
 /**
  * Database-specific table configuration functions
@@ -300,6 +390,13 @@ declare abstract class ModelBuilder {
     schemas: Map<string, unknown>;
     schema: string;
   }): void;
+  /**
+   * Build a view from a view primitive.
+   */
+  abstract buildView(view: ViewPrimitive, options: {
+    tables: Map<string, unknown>;
+    schema: string;
+  }): void;
   /**
    * Build a sequence from a sequence primitive.
    */
@@ -5166,6 +5263,17 @@ declare class DrizzleKitProvider {
    * The actual schema is applied at migration execution time via `search_path`.
    */
   getModelsWithoutSchema(provider: DatabaseProvider): Record<string, unknown>;
+  /**
+   * Preview schema push without executing any statements.
+   *
+   * Returns the SQL statements that would be executed, warnings, and
+   * whether data loss would occur. Does NOT execute any SQL.
+   */
+  dryRunPush(provider: DatabaseProvider): Promise<{
+    statements: string[];
+    warnings: string[];
+    hasDataLoss: boolean;
+  }>;
   protected pushSqlite(kit: typeof api_d_exports, models: Record<string, unknown>, provider: DatabaseProvider): Promise<void>;
   /**
    * Push schema changes to PostgreSQL using Drizzle Kit's pushSchema with schema filters.
@@ -5226,6 +5334,12 @@ declare abstract class DatabaseProvider {
   protected readonly sequencePrimitives: SequencePrimitive[];
   get name(): string;
   get driver(): string;
+  /**
+   * Whether this driver supports SQL-level transactions (BEGIN/COMMIT/ROLLBACK).
+   *
+   * Drivers that do not (e.g. PGlite, Cloudflare D1) should override to `false`.
+   */
+  get supportsTransactions(): boolean;
   /**
    * Raw database connection handle (e.g. DatabaseSync, bun:sqlite Database).
    * Override in providers that expose native connections for introspection.
@@ -5247,6 +5361,7 @@ declare abstract class DatabaseProvider {
   protected parseOperation(sql: string): string;
   table<T extends TObject>(entity: EntityPrimitive<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
   registerEntity(entity: EntityPrimitive): void;
+  registerView(view: ViewPrimitive): void;
   registerSequence(sequence: SequencePrimitive): void;
   /**
    * Rebuild all models into fresh maps using a different schema.
@@ -5331,6 +5446,10 @@ declare class SqliteModelBuilder extends ModelBuilder {
     schemas: Map<string, unknown>;
     schema: string;
   }): void;
+  buildView(view: ViewPrimitive, options: {
+    tables: Map<string, unknown>;
+    schema: string;
+  }): void;
   buildSequence(sequence: SequencePrimitive, options: {
     sequences: Map<string, unknown>;
     schema: string;
@@ -5504,6 +5623,7 @@ declare module "alepha" {
 declare class NodeSqliteProvider extends DatabaseProvider {
   protected readonly env: {
     DATABASE_URL?: string | undefined;
+    DATABASE_SYNC?: boolean | undefined;
   };
   protected readonly builder: SqliteModelBuilder;
   protected readonly options: Readonly<{
@@ -6299,6 +6419,12 @@ type PgQueryWhereConditions<T extends TObject, Relations extends PgRelationMap<T
    * @see notExists for the inverse of this test
    */
   exists?: SQLWrapper;
+  /**
+   * Test whether a subquery evaluates to have no rows.
+   *
+   * @see exists for the inverse of this test
+   */
+  notExists?: SQLWrapper;
 };
 type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["schema"], Relations[K]["with"]> } : {};
 //#endregion
@@ -6402,6 +6528,77 @@ interface PgAttrField {
   one?: boolean;
 }
 //#endregion
+//#region ../../src/orm/core/interfaces/AggregateQuery.d.ts
+type AggregateOp = "count" | "sum" | "avg" | "min" | "max";
+/**
+ * Select definition for aggregate queries.
+ * - `true` means select the column value as-is (used for groupBy columns).
+ * - `{ sum: true, avg: true, ... }` means compute those aggregations.
+ */
+type AggregateColumnSelect = true | Partial<Record<AggregateOp, true>>;
+type AggregateSelect<T extends TObject> = { [K in keyof Static<T>]?: AggregateColumnSelect };
+/**
+ * Maps a single column's select definition to its result type.
+ * - `true` → original column type
+ * - `{ sum: true, avg: true }` → `{ sum: number; avg: number }`
+ */
+type AggregateColumnResult<TValue, TSelect> = TSelect extends true ? TValue : { [Op in AggregateOp as TSelect extends Record<Op, true> ? Op : never]: number };
+/**
+ * Result type for an aggregate query.
+ */
+type AggregateResult<T extends TObject, S extends AggregateSelect<T>> = { [K in keyof S & keyof Static<T>]: AggregateColumnResult<Static<T>[K], NonNullable<S[K]>> };
+/**
+ * HAVING clause for aggregate queries.
+ * Only applies to columns with aggregate operations (not `true`).
+ */
+type AggregateHaving<T extends TObject, S extends AggregateSelect<T>> = { [K in keyof S & keyof Static<T>]?: S[K] extends true ? never : { [Op in AggregateOp as S[K] extends Record<Op, true> ? Op : never]?: {
+  gt?: number;
+  gte?: number;
+  lt?: number;
+  lte?: number;
+  eq?: number;
+  ne?: number;
+} } };
+/**
+ * Full aggregate query definition.
+ */
+interface AggregateQuery<T extends TObject, S extends AggregateSelect<T>> {
+  /**
+   * Columns and aggregate operations to select.
+   */
+  select: S;
+  /**
+   * WHERE clause to filter rows before aggregation.
+   */
+  where?: PgQueryWhereOrSQL<T>;
+  /**
+   * Columns to group by.
+   */
+  groupBy?: (keyof Static<T>)[];
+  /**
+   * HAVING clause to filter groups after aggregation.
+   */
+  having?: AggregateHaving<T, S>;
+  /**
+   * Order results. Supports dot notation for aggregate columns (e.g. "amount.sum").
+   */
+  orderBy?: string | {
+    column: string;
+    direction: "asc" | "desc";
+  } | Array<{
+    column: string;
+    direction: "asc" | "desc";
+  }>;
+  /**
+   * Limit the number of results.
+   */
+  limit?: number;
+  /**
+   * Offset for pagination.
+   */
+  offset?: number;
+}
+//#endregion
 //#region ../../src/orm/core/providers/DatabaseTypeProvider.d.ts
 declare class DatabaseTypeProvider {
   readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
@@ -6508,6 +6705,36 @@ declare const db: DatabaseTypeProvider;
  */
 declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<alepha.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 //#endregion
+//#region ../../src/orm/core/providers/DbCacheProvider.d.ts
+/**
+ * Database query cache using a simple in-memory Map.
+ *
+ * Uses `{tableName}:{cacheKey}` as the storage key.
+ * Provides per-table invalidation for write-through cache busting.
+ *
+ * This is intentionally self-contained (no external cache dependencies)
+ * so the ORM module does not force `AlephaCache` on all consumers.
+ */
+declare class DbCacheProvider {
+  protected readonly store: Map<string, {
+    value: unknown;
+    expiresAt?: number;
+  }>;
+  protected storeKey(tableName: string, cacheKey: string): string;
+  /**
+   * Get a cached query result.
+   */
+  get<T>(tableName: string, cacheKey: string): Promise<T | undefined>;
+  /**
+   * Store a query result in the cache.
+   */
+  set<T>(tableName: string, cacheKey: string, value: T, ttl?: number): Promise<void>;
+  /**
+   * Invalidate all cached queries for a table.
+   */
+  invalidateTable(tableName: string): Promise<void>;
+}
+//#endregion
 //#region ../../src/orm/core/services/QueryManager.d.ts
 declare class QueryManager {
   protected readonly alepha: Alepha;
@@ -6610,6 +6837,7 @@ declare abstract class Repository<T extends TObject> {
   protected readonly relationManager: PgRelationManager;
   protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly dbCache: DbCacheProvider;
   protected readonly alepha: Alepha;
   static of<T extends TObject>(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider): new () => Repository<T>;
   constructor(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider);
@@ -6633,6 +6861,10 @@ declare abstract class Repository<T extends TObject> {
    * Get SQL table name. (from Drizzle table object)
    */
   get tableName(): string;
+  /**
+   * Whether this repository is backed by a view (read-only).
+   */
+  get isReadOnly(): boolean;
   /**
    * Getter for the database connection from the database provider.
    *
@@ -6864,6 +7096,21 @@ declare abstract class Repository<T extends TObject> {
    * Count entities.
    */
   count(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<number>;
+  /**
+   * Execute an aggregate query with type-safe select, groupBy, and having.
+   *
+   * @example
+   * ```ts
+   * const result = await repo.aggregate({
+   *   select: { category: true, amount: { sum: true, avg: true } },
+   *   groupBy: ["category"],
+   *   having: { amount: { sum: { gt: 100 } } },
+   *   orderBy: { column: "amount.sum", direction: "desc" },
+   * });
+   * // result: Array<{ category: string; amount: { sum: number; avg: number } }>
+   * ```
+   */
+  aggregate<S extends AggregateSelect<T>>(query: AggregateQuery<T, S>, opts?: StatementOptions): Promise<AggregateResult<T, S>[]>;
   protected errorPatterns: {
     conflict: string[];
     foreignKey: string[];
@@ -6889,6 +7136,18 @@ declare abstract class Repository<T extends TObject> {
    * Clean a row with joins recursively
    */
   protected cleanWithJoins<T extends TObject>(row: Record<string, unknown>, schema: T, joins: PgJoin[], parentPath?: string): Static<T>;
+  /**
+   * Throw if this repository is read-only (backed by a view).
+   */
+  protected assertWritable(): void;
+  /**
+   * Refresh a materialized view. PostgreSQL only.
+   */
+  refresh(): Promise<void>;
+  /**
+   * Build a cache key from method name and query parameters.
+   */
+  protected buildCacheKey(method: string, query: any): string;
   /**
    * Convert a where clause to SQL.
    */
@@ -6936,14 +7195,35 @@ interface StatementOptions {
    * Force the current time.
    */
   now?: DateTime | string;
+  /**
+   * Cache configuration for query results.
+   *
+   * When set, results are stored in an in-memory cache keyed by query parameters.
+   * Any write to this table automatically invalidates all cached queries.
+   *
+   * @example
+   * ```ts
+   * await repo.findMany(query, { cache: { ttl: 60_000 } });
+   * ```
+   */
+  cache?: {
+    /**
+     * Time-to-live in milliseconds.
+     */
+    ttl?: number;
+    /**
+     * Custom cache key. If not provided, a key is derived from the query.
+     */
+    key?: string;
+  };
 }
 type WithSQL<T> = { [P in keyof T]?: T[P] | SQL };
 //#endregion
 //#region ../../src/orm/core/primitives/$repository.d.ts
 /**
- * Get the repository for the given entity.
+ * Get the repository for the given entity or view.
  */
-declare const $repository: <T extends TObject>(entity: EntityPrimitive<T>) => Repository<T>;
+declare const $repository: <T extends TObject>(entity: EntityPrimitive<T> | ViewPrimitive<T>) => Repository<T>;
 //#endregion
 //#region ../../src/orm/core/primitives/$seed.d.ts
 interface SeedOptions {
@@ -7068,6 +7348,15 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   get url(): string;
   get db(): PgDatabase<any>;
   execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
+  /**
+   * D1 does not support SQL-level transactions (BEGIN/COMMIT/ROLLBACK).
+   * It rejects these statements and requires the JS `batch()` API for atomic
+   * multi-statement operations instead.
+   *
+   * @see https://developers.cloudflare.com/d1/worker-api/d1-database/#batch-statements
+   * @see https://github.com/drizzle-team/drizzle-orm/issues/2463
+   */
+  get supportsTransactions(): boolean;
   protected readonly onStart: alepha.HookPrimitive<"start">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
   /**
@@ -7086,6 +7375,35 @@ declare class RepositoryProvider {
   createClassRepository<T extends TObject>(entity: EntityPrimitive<T>): Service<Repository<T>>;
 }
 //#endregion
+//#region ../../src/orm/core/schemas/databaseEnvSchema.d.ts
+/**
+ * Base database environment schema.
+ *
+ * Defines the `DATABASE_URL` connection string used by all ORM providers
+ * to determine the database driver and connection target.
+ *
+ * Supported URL formats:
+ * - `sqlite://:memory:` or `sqlite://./path/to/db` — SQLite (Node.js or Bun)
+ * - `postgres://user:password@host:port/database` — PostgreSQL (Node.js or Bun)
+ * - `pglite://:memory:` or `pglite://./path` — PGlite (embedded Postgres)
+ * - `d1://BINDING_NAME` — Cloudflare D1
+ * - `hyperdrive://BINDING_NAME` — Cloudflare Hyperdrive
+ */
+declare const databaseEnvSchema: alepha.TObject<{
+  DATABASE_URL: alepha.TOptional<alepha.TString>;
+  /**
+   * Enable or disable push-based schema synchronization (drizzle-kit push).
+   *
+   * Defaults to `true` in development and test, `false` in production.
+   * Set to `false` in development to skip automatic schema sync
+   * (e.g. when managing migrations manually).
+   */
+  DATABASE_SYNC: alepha.TOptional<alepha.TBoolean>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof databaseEnvSchema>> {}
+} //# sourceMappingURL=databaseEnvSchema.d.ts.map
+//#endregion
 //#region ../../src/orm/core/types/schema.d.ts
 /**
  * Postgres schema type.
@@ -7160,6 +7478,7 @@ declare module "alepha" {
 declare class BunSqliteProvider extends DatabaseProvider {
   protected readonly env: {
     DATABASE_URL?: string | undefined;
+    DATABASE_SYNC?: boolean | undefined;
   };
   protected readonly builder: SqliteModelBuilder;
   protected readonly options: Readonly<{
@@ -7178,7 +7497,7 @@ declare class BunSqliteProvider extends DatabaseProvider {
   protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 declare namespace index_d_exports {
-  export { $entity, $repository, $seed, $sequence, $transactional, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database$1 as D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pgAttr, schema, sql, updateSchema };
+  export { $entity, $repository, $seed, $sequence, $transactional, $view, AggregateColumnResult, AggregateColumnSelect, AggregateHaving, AggregateOp, AggregateQuery, AggregateResult, AggregateSelect, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database$1 as D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbCacheProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_GENERATED, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgGeneratedOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, ViewPrimitive, ViewPrimitiveOptions, buildQueryString, bunSqliteOptions, databaseEnvSchema, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pgAttr, schema, sql, updateSchema };
 }
 declare module "alepha" {
   interface State {
@@ -7252,5 +7571,5 @@ declare module "alepha" {
 declare const SqliteProvider: typeof NodeSqliteProvider;
 declare const AlephaOrm: alepha.Service<alepha.Module>;
 //#endregion
-export { $entity, $repository, $seed, $sequence, $transactional, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database$1 as D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pgAttr, schema, sql, updateSchema };
+export { $entity, $repository, $seed, $sequence, $transactional, $view, AggregateColumnResult, AggregateColumnSelect, AggregateHaving, AggregateOp, AggregateQuery, AggregateResult, AggregateSelect, AlephaOrm, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database$1 as D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbCacheProvider, DbColumnNotFoundError, DbConflictError, DbConnectionError, DbDeadlockError, DbEntityNotFoundError, DbError, DbForeignKeyError, DbMigrationError, DbMigrationMode, DbNotNullError, DbTableNotFoundError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, ModelBuilder, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_GENERATED, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgGeneratedOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SeedOptions, SequencePrimitive, SequencePrimitiveOptions, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TableConfigBuilders, TransactionalOptions, ViewPrimitive, ViewPrimitiveOptions, buildQueryString, bunSqliteOptions, databaseEnvSchema, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map