alepha 0.10.3 → 0.10.4

package/postgres.d.ts

@@ -1,9 +1,9 @@
 import * as _alepha_core1 from "alepha";
-import { Alepha, AlephaError, Descriptor, KIND, Service, Static, TArray, TBigInt, TBoolean, TInteger, TKeysToIndexer, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TOptionalAdd, TPick, TRecord, TSchema as TSchema$1, TString, TStringOptions, TUnion } from "alepha";
+import { Alepha, AlephaError, Descriptor, KIND, Service, Static, TArray, TBigInt, TBoolean, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TOptionalAdd, TRecord, TSchema as TSchema$1, TString, TStringOptions, TUnion } from "alepha";
 import * as drizzle_orm6 from "drizzle-orm";
 import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, TableConfig, sql } from "drizzle-orm";
 import * as pg$1 from "drizzle-orm/pg-core";
-import { AnyPgColumn, LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, SelectedFields, TableConfig as TableConfig$1, UpdateDeleteAction } from "drizzle-orm/pg-core";
+import { AnyPgColumn, AnyPgTable, LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, SelectedFields, TableConfig as TableConfig$1, UpdateDeleteAction } from "drizzle-orm/pg-core";
 import { DateTime, DateTimeProvider } from "alepha/datetime";
 import * as _alepha_logger1 from "alepha/logger";
 import * as _alepha_lock0 from "alepha/lock";
@@ -28,12 +28,16 @@ declare const PG_UPDATED_AT: unique symbol;
 declare const PG_DELETED_AT: unique symbol;
 declare const PG_VERSION: unique symbol;
 declare const PG_IDENTITY: unique symbol;
+declare const PG_MANY: unique symbol;
+declare const PG_ONE: unique symbol;
 declare const PG_REF: unique symbol;
 /**
  * @deprecated Use `PG_IDENTITY` instead.
  */
 declare const PG_SERIAL: unique symbol;
 type PgDefault = typeof PG_DEFAULT;
+type PgMany = typeof PG_MANY;
+type PgOne = typeof PG_ONE;
 type PgRef = typeof PG_REF;
 type PgPrimaryKey = typeof PG_PRIMARY_KEY;
 type PgSymbols = {
@@ -44,6 +48,8 @@ type PgSymbols = {
   [PG_DELETED_AT]: {};
   [PG_VERSION]: {};
   [PG_IDENTITY]: PgIdentityOptions;
+  [PG_MANY]: PgManyOptions;
+  [PG_ONE]: PgManyOptions;
   [PG_REF]: PgRefOptions;
   /**
    * @deprecated Use `PG_IDENTITY` instead.
@@ -56,6 +62,11 @@ type PgIdentityOptions = {
 } & PgSequenceOptions & {
   name?: string;
 };
+interface PgManyOptions {
+  table: AnyPgTable;
+  schema: TObject;
+  foreignKey: string;
+}
 interface PgRefOptions {
   ref: () => AnyPgColumn;
   actions?: {
@@ -305,10 +316,10 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
  *   name: "users",
  *   schema: t.object({
  *     id: pg.primaryKey(t.uuid()),
- *     email: t.string({ format: "email" }),
- *     username: t.string({ minLength: 3, maxLength: 30 }),
- *     firstName: t.string(),
- *     lastName: t.string(),
+ *     email: t.text({ format: "email" }),
+ *     username: t.text({ minLength: 3, maxLength: 30 }),
+ *     firstName: t.text(),
+ *     lastName: t.text(),
  *     isActive: t.boolean({ default: true }),
  *     createdAt: pg.createdAt(),
  *     updatedAt: pg.updatedAt(),
@@ -330,15 +341,15 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
  *   name: "products",
  *   schema: t.object({
  *     id: pg.primaryKey(t.uuid()),
- *     sku: t.string({ minLength: 3 }),
- *     name: t.string({ minLength: 1, maxLength: 200 }),
- *     description: t.optional(t.string()),
+ *     sku: t.text({ minLength: 3 }),
+ *     name: t.text({ minLength: 1, maxLength: 200 }),
+ *     description: t.optional(t.text()),
  *     price: t.number({ minimum: 0 }),
- *     categoryId: t.string({ format: "uuid" }),
+ *     categoryId: t.text({ format: "uuid" }),
  *     inStock: t.boolean({ default: true }),
  *     stockQuantity: t.integer({ minimum: 0, default: 0 }),
- *     tags: t.optional(t.array(t.string())), // PostgreSQL array column
- *     metadata: t.optional(t.record(t.string(), t.any())), // JSONB column
+ *     tags: t.optional(t.array(t.text())), // PostgreSQL array column
+ *     metadata: t.optional(t.record(t.text(), t.any())), // JSONB column
  *     version: pg.version(),
  *     createdAt: pg.createdAt(),
  *     updatedAt: pg.updatedAt()
@@ -367,15 +378,15 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
  *   name: "audit_logs",
  *   schema: t.object({
  *     id: pg.primaryKey(t.uuid()),
- *     tableName: t.string(),
- *     recordId: t.string(),
+ *     tableName: t.text(),
+ *     recordId: t.text(),
  *     action: t.enum(["CREATE", "UPDATE", "DELETE"]),
- *     userId: t.optional(t.string({ format: "uuid" })),
- *     oldValues: t.optional(t.record(t.string(), t.any())),
- *     newValues: t.optional(t.record(t.string(), t.any())),
+ *     userId: t.optional(t.text({ format: "uuid" })),
+ *     oldValues: t.optional(t.record(t.text(), t.any())),
+ *     newValues: t.optional(t.record(t.text(), t.any())),
  *     timestamp: pg.createdAt(),
- *     ipAddress: t.optional(t.string()),
- *     userAgent: t.optional(t.string())
+ *     ipAddress: t.optional(t.text()),
+ *     userAgent: t.optional(t.text())
  *   }),
  *   indexes: [
  *     "tableName",
@@ -403,9 +414,9 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
  *   name: "user_roles",
  *   schema: t.object({
  *     id: pg.primaryKey(t.uuid()),
- *     userId: t.string({ format: "uuid" }),
- *     roleId: t.string({ format: "uuid" }),
- *     assignedBy: t.string({ format: "uuid" }),
+ *     userId: t.text({ format: "uuid" }),
+ *     roleId: t.text({ format: "uuid" }),
+ *     assignedBy: t.text({ format: "uuid" }),
  *     assignedAt: pg.createdAt(),
  *     expiresAt: t.optional(t.datetime())
  *   }),
@@ -440,12 +451,12 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
  *   name: "orders",
  *   schema: t.object({
  *     id: pg.primaryKey(t.uuid()),
- *     orderNumber: t.string(),
- *     customerId: t.string({ format: "uuid" }),
+ *     orderNumber: t.text(),
+ *     customerId: t.text({ format: "uuid" }),
  *     status: t.enum(["pending", "processing", "shipped", "delivered"]),
  *     totalAmount: t.number({ minimum: 0 }),
- *     currency: t.string({ default: "USD" }),
- *     notes: t.optional(t.string()),
+ *     currency: t.text({ default: "USD" }),
+ *     notes: t.optional(t.text()),
  *     createdAt: pg.createdAt(),
  *     updatedAt: pg.updatedAt(),
  *     version: pg.version()
@@ -511,11 +522,11 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject,
    *
    * **Supported PostgreSQL Types**:
    * - `pg.primaryKey(t.uuid())` - UUID primary key
-   * - `t.string()` - VARCHAR column
+   * - `t.text()` - VARCHAR column
    * - `t.integer()`, `t.number()` - Numeric columns
    * - `t.boolean()` - Boolean column
-   * - `t.array(t.string())` - PostgreSQL array column
-   * - `t.record(t.string(), t.any())` - JSONB column
+   * - `t.array(t.text())` - PostgreSQL array column
+   * - `t.record(t.text(), t.any())` - JSONB column
    * - `pg.createdAt()`, `pg.updatedAt()`, `pg.deletedAt()` - Audit timestamps
    * - `pg.version()` - Optimistic locking version field
    *
@@ -530,13 +541,13 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject,
    * ```ts
    * t.object({
    *   id: pg.primaryKey(t.uuid()),
-   *   email: t.string({ format: "email" }),
-   *   firstName: t.string({ minLength: 1, maxLength: 100 }),
-   *   lastName: t.string({ minLength: 1, maxLength: 100 }),
+   *   email: t.text({ format: "email" }),
+   *   firstName: t.text({ minLength: 1, maxLength: 100 }),
+   *   lastName: t.text({ minLength: 1, maxLength: 100 }),
    *   age: t.optional(t.integer({ minimum: 0, maximum: 150 })),
    *   isActive: t.boolean({ default: true }),
-   *   preferences: t.optional(t.record(t.string(), t.any())),
-   *   tags: t.optional(t.array(t.string())),
+   *   preferences: t.optional(t.record(t.text(), t.any())),
+   *   tags: t.optional(t.array(t.text())),
    *   createdAt: pg.createdAt(),
    *   updatedAt: pg.updatedAt(),
    *   version: pg.version()
@@ -765,6 +776,7 @@ interface PgAttrField {
   type: TSchema$1;
   data: any;
   nested?: any[];
+  one?: boolean;
 }
 //#endregion
 //#region src/interfaces/FilterOperators.d.ts
@@ -1124,8 +1136,7 @@ interface FilterOperators<TValue> {
 }
 //#endregion
 //#region src/interfaces/PgQueryWhere.d.ts
-type PgQueryWhereOrSQL<T extends object> = SQLWrapper | PgQueryWhere<T>;
-type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key]> | T[Key] } & {
+type PgQueryWhere<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] } & {
   /**
    * Combine a list of conditions with the `and` operator. Conditions
    * that are equal `undefined` are automatically ignored.
@@ -1194,6 +1205,26 @@ type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key
    */
   exists?: SQLWrapper;
 };
+type PgQueryWhereOrSQL<T extends TObject> = SQLWrapper | PgQueryWhere<T>;
+type PgQueryWhereWithManyOrSQL<T extends TObject> = SQLWrapper | PgQueryWhereWithMany<T>;
+type PgQueryWhereWithMany<T extends TObject> = PgQueryWhere<RemoveManyRelations<T>> & ExtractManyRelations<T>;
+type RelField = {
+  [PG_MANY]: any;
+} | {
+  [PG_ONE]: any;
+};
+type ExtractManyRelations<T extends TObject> = { [K in keyof T["properties"] as T["properties"][K] extends RelField ? T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? K : never : never : T["properties"][K] extends TObject ? K : never]?: PgQueryWhere<T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? T["properties"][K]["items"] : TObject : T["properties"][K] extends TObject ? T["properties"][K] : TObject> };
+type RemoveManyRelations<T extends TObject> = TObject<{ [K in keyof T["properties"] as T["properties"][K] extends RelField ? never : K]: T["properties"][K] }>;
+type PgQueryWithMap<T extends TObject> = { [K in keyof T["properties"] as T["properties"][K] extends RelField ? K : never]?: T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject ? PgQueryWithMany<T["properties"][K]["items"]> : never : T["properties"][K] extends TObject ? PgQueryWithOne<T["properties"][K]> : T["properties"][K] extends PgAttr<PgAttr<TOptionalAdd<infer U>, PgOne>, PgDefault> ? U extends TObject ? PgQueryWithOne<U> : never : never };
+type PgQueryWithOne<T extends TObject> = true | {
+  columns?: (keyof Static<T>)[];
+  relations?: PgQueryWithMap<T>;
+};
+type PgQueryWithMany<T extends TObject> = true | {
+  limit?: number;
+  columns?: (keyof Static<T>)[];
+  relations?: PgQueryWithMap<T>;
+};
 //#endregion
 //#region src/interfaces/PgQuery.d.ts
 /**
@@ -1214,24 +1245,25 @@ interface OrderByClause<T> {
  * 3. Array: orderBy: [{ column: "name", direction: "asc" }, { column: "age", direction: "desc" }]
  */
 type OrderBy<T> = keyof T | OrderByClause<T> | Array<OrderByClause<T>>;
-interface PgQuery<T extends TObject> {
+interface PgQuery<T extends TObject = TObject> {
   distinct?: boolean;
-  where?: PgQueryWhereOrSQL<Static<T>>;
+  where?: PgQueryWhereWithMany<T> | SQLWrapper;
   limit?: number;
   offset?: number;
   orderBy?: OrderBy<Static<T>>;
   groupBy?: (keyof Static<T>)[];
+  relations?: PgQueryWithMap<T>;
 }
-type PgQueryResult<T extends TObject, Select extends (keyof Static<T>)[]> = TPick<T, TKeysToIndexer<Select>>;
 //#endregion
 //#region src/providers/drivers/PostgresProvider.d.ts
 type SQLLike = SQLWrapper | string;
 declare abstract class PostgresProvider {
   protected readonly alepha: Alepha;
   abstract get db(): PgDatabase<any>;
-  abstract get schema(): string;
-  abstract get dialect(): string;
-  abstract execute<T extends TObject | undefined = undefined>(query: SQLLike, schema?: T): Promise<Array<T extends TObject ? Static<T> : any>>;
+  readonly dialect: "postgres" | "sqlite";
+  get schema(): string;
+  execute<T extends TObject | undefined>(query: SQLLike, schema?: T): Promise<Array<T extends TObject ? Static<T> : any>>;
+  protected mapResult<T extends TObject = any>(result: Array<any>, schema?: T): Array<T extends TObject ? Static<T> : any>;
 }
 //#endregion
 //#region src/schemas/pageQuerySchema.d.ts
@@ -1247,7 +1279,7 @@ type PageQuery = Static<typeof pageQuerySchema>;
  * Create a pagination schema for the given object schema.
  *
  * @example
- * const userSchema = t.object({ id: t.int(), name: t.string() });
+ * const userSchema = t.object({ id: t.int(), name: t.text() });
  * const pagedUserSchema = pageSchema(userSchema);
  *
  * @see {@link $repository#paginate}
@@ -1323,9 +1355,9 @@ type Page<T> = {
  *   name: "users",
  *   schema: t.object({
  *     id: pg.primaryKey(t.uuid()),
- *     email: t.string({ format: "email" }),
- *     firstName: t.string(),
- *     lastName: t.string(),
+ *     email: t.text({ format: "email" }),
+ *     firstName: t.text(),
+ *     lastName: t.text(),
  *     isActive: t.boolean({ default: true }),
  *     createdAt: pg.createdAt(),
  *     updatedAt: pg.updatedAt()
@@ -1359,238 +1391,6 @@ type Page<T> = {
  *   }
  * }
  * ```
- *
- * @example
- * **Advanced querying and filtering:**
- * ```ts
- * const Product = $entity({
- *   name: "products",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     name: t.string(),
- *     price: t.number({ minimum: 0 }),
- *     categoryId: t.string({ format: "uuid" }),
- *     inStock: t.boolean(),
- *     tags: t.optional(t.array(t.string())),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt()
- *   }),
- *   indexes: ["categoryId", "inStock", "price"]
- * });
- *
- * class ProductService {
- *   products = $repository({ table: Product });
- *
- *   async searchProducts(filters: {
- *     categoryId?: string;
- *     minPrice?: number;
- *     maxPrice?: number;
- *     inStock?: boolean;
- *     searchTerm?: string;
- *   }, page: number = 0, size: number = 20) {
- *     const query = this.products.createQuery({
- *       where: {
- *         and: [
- *           filters.categoryId ? { categoryId: filters.categoryId } : {},
- *           filters.inStock !== undefined ? { inStock: filters.inStock } : {},
- *           filters.minPrice ? { price: { gte: filters.minPrice } } : {},
- *           filters.maxPrice ? { price: { lte: filters.maxPrice } } : {},
- *           filters.searchTerm ? { name: { ilike: `%${filters.searchTerm}%` } } : {}
- *         ]
- *       },
- *       orderBy: [{ column: "createdAt", direction: "desc" }]
- *     });
- *
- *     return await this.products.paginate({ page, size }, query, { count: true });
- *   }
- *
- *   async getTopSellingProducts(limit: number = 10) {
- *     // Custom SQL query for complex analytics
- *     return await this.products.query(
- *       (table, db) => db
- *         .select({
- *           id: table.id,
- *           name: table.name,
- *           price: table.price,
- *           salesCount: sql<number>`COALESCE(sales.count, 0)`
- *         })
- *         .from(table)
- *         .leftJoin(
- *           sql`(
- *             SELECT product_id, COUNT(*) as count
- *             FROM order_items
- *             WHERE created_at > NOW() - INTERVAL '30 days'
- *             GROUP BY product_id
- *           ) sales`,
- *           sql`sales.product_id = ${table.id}`
- *         )
- *         .orderBy(sql`sales.count DESC NULLS LAST`)
- *         .limit(limit)
- *     );
- *   }
- * }
- * ```
- *
- * @example
- * **Transaction handling and data consistency:**
- * ```ts
- * class OrderService {
- *   orders = $repository({ table: Order });
- *   orderItems = $repository({ table: OrderItem });
- *   products = $repository({ table: Product });
- *
- *   async createOrderWithItems(orderData: {
- *     customerId: string;
- *     items: Array<{ productId: string; quantity: number; price: number }>;
- *   }) {
- *     return await this.orders.transaction(async (tx) => {
- *       // Create the order
- *       const order = await this.orders.create({
- *         id: generateUUID(),
- *         customerId: orderData.customerId,
- *         status: 'pending',
- *         totalAmount: orderData.items.reduce((sum, item) => sum + (item.price * item.quantity), 0)
- *       }, { tx });
- *
- *       // Create order items and update product inventory
- *       for (const itemData of orderData.items) {
- *         await this.orderItems.create({
- *           id: generateUUID(),
- *           orderId: order.id,
- *           productId: itemData.productId,
- *           quantity: itemData.quantity,
- *           unitPrice: itemData.price
- *         }, { tx });
- *
- *         // Update product inventory using optimistic locking
- *         const product = await this.products.findById(itemData.productId, { tx });
- *         if (product.stockQuantity < itemData.quantity) {
- *           throw new Error(`Insufficient stock for product ${itemData.productId}`);
- *         }
- *
- *         await this.products.save({
- *           ...product,
- *           stockQuantity: product.stockQuantity - itemData.quantity
- *         }, { tx });
- *       }
- *
- *       return order;
- *     });
- *   }
- * }
- * ```
- *
- * @example
- * **Soft delete and audit trail:**
- * ```ts
- * const Document = $entity({
- *   name: "documents",
- *   schema: t.object({
- *     id: pg.primaryKey(t.uuid()),
- *     title: t.string(),
- *     content: t.string(),
- *     authorId: t.string({ format: "uuid" }),
- *     version: pg.version(),
- *     createdAt: pg.createdAt(),
- *     updatedAt: pg.updatedAt(),
- *     deletedAt: pg.deletedAt()  // Enables soft delete
- *   })
- * });
- *
- * class DocumentService {
- *   documents = $repository({ table: Document });
- *
- *   async updateDocument(id: string, updates: { title?: string; content?: string }) {
- *     // This uses optimistic locking via the version field
- *     const document = await this.documents.findById(id);
- *     return await this.documents.save({
- *       ...document,
- *       ...updates  // updatedAt will be set automatically
- *     });
- *   }
- *
- *   async softDeleteDocument(id: string) {
- *     // Soft delete - sets deletedAt timestamp
- *     await this.documents.deleteById(id);
- *   }
- *
- *   async permanentDeleteDocument(id: string) {
- *     // Hard delete - actually removes from database
- *     await this.documents.deleteById(id, { force: true });
- *   }
- *
- *   async getActiveDocuments() {
- *     // Automatically excludes soft-deleted records
- *     return await this.documents.find({
- *       where: { authorId: { isNotNull: true } },
- *       orderBy: [{ column: "updatedAt", direction: "desc" }]
- *     });
- *   }
- *
- *   async getAllDocumentsIncludingDeleted() {
- *     // Include soft-deleted records
- *     return await this.documents.find({}, { force: true });
- *   }
- * }
- * ```
- *
- * @example
- * **Complex filtering and aggregation:**
- * ```ts
- * class AnalyticsService {
- *   users = $repository({ table: User });
- *   orders = $repository({ table: Order });
- *
- *   async getUserStatistics(filters: {
- *     startDate?: string;
- *     endDate?: string;
- *     isActive?: boolean;
- *   }) {
- *     const whereConditions = [];
- *
- *     if (filters.startDate) {
- *       whereConditions.push({ createdAt: { gte: filters.startDate } });
- *     }
- *     if (filters.endDate) {
- *       whereConditions.push({ createdAt: { lte: filters.endDate } });
- *     }
- *     if (filters.isActive !== undefined) {
- *       whereConditions.push({ isActive: filters.isActive });
- *     }
- *
- *     const totalUsers = await this.users.count({
- *       and: whereConditions
- *     });
- *
- *     const activeUsers = await this.users.count({
- *       and: [...whereConditions, { isActive: true }]
- *     });
- *
- *     // Complex aggregation query
- *     const recentActivity = await this.users.query(
- *       sql`
- *         SELECT
- *           DATE_TRUNC('day', created_at) as date,
- *           COUNT(*) as new_users,
- *           COUNT(*) FILTER (WHERE is_active = true) as active_users
- *         FROM users
- *         WHERE created_at >= NOW() - INTERVAL '30 days'
- *         GROUP BY DATE_TRUNC('day', created_at)
- *         ORDER BY date DESC
- *       `
- *     );
- *
- *     return {
- *       totalUsers,
- *       activeUsers,
- *       inactiveUsers: totalUsers - activeUsers,
- *       recentActivity
- *     };
- *   }
- * }
- * ```
- *
- * @stability 3
  */
 declare const $repository: {
   <EntityTableConfig extends TableConfig, EntitySchema extends TObject>(optionsOrTable: RepositoryDescriptorOptions<EntityTableConfig, EntitySchema> | PgTableWithColumnsAndSchema<EntityTableConfig, EntitySchema>): RepositoryDescriptor<EntityTableConfig, EntitySchema>;
@@ -1623,8 +1423,8 @@ interface RepositoryDescriptorOptions<EntityTableConfig extends TableConfig, Ent
    *   name: "users",
    *   schema: t.object({
    *     id: pg.primaryKey(t.uuid()),
-   *     email: t.string({ format: "email" }),
-   *     name: t.string()
+   *     email: t.text({ format: "email" }),
+   *     name: t.text()
    *   })
    * });
    *
@@ -1753,7 +1553,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param opts The statement options.
    * @returns The found entity.
    */
-  findOne<T extends Static<EntitySchema> = Static<EntitySchema>>(where: PgQueryWhere<T>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  findOne<T extends EntitySchema = EntitySchema>(where: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
   /**
    * Find an entity by ID.
    */
@@ -1765,7 +1565,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
     count?: boolean;
   }): Promise<Page<Static<EntitySchema>>>;
   createQuery(query?: PgQuery<EntitySchema>): PgQuery<EntitySchema>;
-  createQueryWhere(where?: PgQueryWhere<Static<EntitySchema>>): PgQueryWhere<Static<EntitySchema>>;
+  createQueryWhere(where?: PgQueryWhere<EntitySchema>): PgQueryWhere<EntitySchema>;
   /**
    * Create an entity.
    *
@@ -1785,7 +1585,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   /**
    * Find an entity and update it.
    */
-  updateOne(where: PgQueryWhereOrSQL<Static<EntitySchema>>, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
+  updateOne(where: PgQueryWhereOrSQL<EntitySchema>, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<Static<EntitySchema>>;
   /**
    * Save a given entity.
    *
@@ -1815,11 +1615,11 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   /**
    * Find many entities and update all of them.
    */
-  updateMany(where: PgQueryWhereOrSQL<Static<EntitySchema>>, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<void>;
+  updateMany(where: PgQueryWhereOrSQL<EntitySchema>, data: Partial<Static<TObjectUpdate<EntitySchema>>>, opts?: StatementOptions): Promise<void>;
   /**
    * Find many and delete all of them.
    */
-  deleteMany(where?: PgQueryWhere<Static<EntitySchema>>, opts?: StatementOptions): Promise<void>;
+  deleteMany(where?: PgQueryWhereOrSQL<EntitySchema>, opts?: StatementOptions): Promise<void>;
   /**
    * Delete all entities.
    */
@@ -1833,7 +1633,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   /**
    * Find an entity and delete it.
    */
-  deleteOne(where?: PgQueryWhere<Static<EntitySchema>>, opts?: StatementOptions): Promise<void>;
+  deleteOne(where?: PgQueryWhereOrSQL<EntitySchema>, opts?: StatementOptions): Promise<void>;
   /**
    * Find an entity by ID and delete it.
    */
@@ -1841,12 +1641,12 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   /**
    * Count entities.
    */
-  count(where?: PgQueryWhereOrSQL<Static<EntitySchema>>, opts?: StatementOptions): Promise<number>;
+  count(where?: PgQueryWhereOrSQL<EntitySchema>, opts?: StatementOptions): Promise<number>;
   protected conflictMessagePattern: string;
   protected handleError(error: unknown, message: string): PgError;
-  protected withDeletedAt(where: PgQueryWhereOrSQL<Static<EntitySchema>>, opts?: {
+  protected withDeletedAt(where: PgQueryWhereOrSQL<EntitySchema>, opts?: {
     force?: boolean;
-  }): PgQueryWhereOrSQL<Static<EntitySchema>>;
+  }): PgQueryWhereOrSQL<EntitySchema>;
   protected get organization(): undefined;
   protected deletedAt(): PgAttrField | undefined;
   /**
@@ -1856,7 +1656,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param schema The schema to use.
    * @param col The column to use.
    */
-  protected jsonQueryToSql(query: PgQueryWhereOrSQL<Static<EntitySchema>>, schema?: TObject, col?: (key: string) => PgColumn): SQL | undefined;
+  protected jsonQueryToSql(query: PgQueryWhereOrSQL<EntitySchema>, schema?: TObject, col?: (key: string) => PgColumn): SQL | undefined;
   /**
    * Map a filter operator to a SQL query.
    *
@@ -1921,7 +1721,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param id The ID to get the where clause for.
    * @returns The where clause for the ID.
    */
-  protected getWhereId(id: string | number): PgQueryWhere<Static<EntitySchema>>;
+  protected getWhereId(id: string | number): PgQueryWhereOrSQL<EntitySchema>;
   /**
    * Find a primary key in the schema.
    *
@@ -2498,7 +2298,9 @@ declare class DrizzleKitProvider {
    * @returns A promise that resolves once the migrations have been executed.
    */
   synchronize(provider: PostgresProvider, schema?: string): Promise<void>;
-  synchronizeSqlite(provider: PostgresProvider): Promise<void>;
+  /**
+   * Get all tables from the provider's repositories.
+   */
   protected getTables(provider: PostgresProvider, schema?: string): Promise<Record<string, any>>;
   protected loadMigrationSnapshot(provider: PostgresProvider): Promise<any>;
   protected saveMigrationSnapshot(provider: PostgresProvider, curr: Record<string, any>, entry?: {
@@ -2511,14 +2313,15 @@ declare class DrizzleKitProvider {
    * Try to load the official Drizzle Kit API.
    * If not available, fallback to the local kit import.
    */
-  protected importDrizzleKit(): Promise<typeof DrizzleKit>;
+  protected importDrizzleKit(): typeof DrizzleKit;
+  synchronizeSqlite(provider: PostgresProvider): Promise<void>;
 }
 //#endregion
 //#region src/providers/drivers/NodePostgresProvider.d.ts
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-declare const envSchema: TObject<{
+declare const envSchema: _alepha_core1.TObject<{
   /**
    * Main configuration for database connection.
    * Accept a string in the format of a Postgres connection URL.
@@ -2580,18 +2383,11 @@ declare class NodePostgresProvider extends PostgresProvider {
    */
   get schema(): string;
   get db(): PostgresJsDatabase;
-  protected readonly configure: _alepha_core1.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
-  execute<T extends TObject | undefined = undefined>(query: SQLLike, schema?: T): Promise<Array<T extends TObject ? Static<T> : any>>;
+  protected readonly onStart: _alepha_core1.HookDescriptor<"start">;
+  protected readonly onStop: _alepha_core1.HookDescriptor<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrate: _alepha_lock0.LockDescriptor<() => Promise<void>>;
-  protected createClient(): {
-    client: postgres.Sql<{}>;
-    db: PostgresJsDatabase<Record<string, never>> & {
-      $client: postgres.Sql<{}>;
-    };
-  };
   /**
    * Generate a minimal migration configuration.
    */
@@ -2605,12 +2401,8 @@ declare class NodePostgresProvider extends PostgresProvider {
    * For testing purposes, generate a unique schema name.
    * The schema name will be generated based on the current date and time.
    * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-   *
-   * TODO: investigate for adding the test file name to the schema name if possible.
-   * TODO: options to skip deletion on failure, in order to inspect the schema?
    */
   protected generateTestSchemaName(): string;
-  protected mapResult<T extends TObject = any>(result: Array<any>, schema?: T): Array<T extends TObject ? Static<T> : any>;
 }
 //#endregion
 //#region src/providers/PostgresTypeProvider.d.ts
@@ -2681,6 +2473,8 @@ declare class PostgresTypeProvider {
    * It's used by {@link RepositoryDescriptor#paginate} method.
    */
   readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
+  readonly many: <T extends TObject, Config extends TableConfig>(table: PgTableWithColumnsAndSchema<Config, T>, foreignKey: keyof T["properties"]) => TOptionalAdd<PgAttr<PgAttr<TArray<T>, PgMany>, PgDefault>>;
+  readonly one: <T extends TObject, Config extends TableConfig>(table: PgTableWithColumnsAndSchema<Config, T>, foreignKey: keyof T["properties"]) => PgAttr<PgAttr<TOptionalAdd<T>, PgOne>, PgDefault>;
 }
 declare const pg: PostgresTypeProvider;
 //#endregion
@@ -2712,8 +2506,8 @@ declare const schema: <TDocument extends TSchema$1>(name: string, document: TDoc
  *   name: "users",
  *   schema: t.object({
  *     id: pg.primaryKey(),
- *     name: t.string(),
- *     email: t.string(),
+ *     name: t.text(),
+ *     email: t.text(),
  *   }),
  * });
  *
@@ -2746,5 +2540,5 @@ declare const schema: <TDocument extends TSchema$1>(name: string, document: TDoc
  */
 declare const AlephaPostgres: _alepha_core1.Service<_alepha_core1.Module<{}>>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DrizzleKitProvider, Entity, EntityDescriptorOptions, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgDefault, PgEntityNotFoundError, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryResult, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PostgresProvider, PostgresTypeProvider, RepositoryDescriptor, RepositoryDescriptorOptions, RepositoryProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, TPage, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle_orm6 as drizzle, insertSchema, legacyIdSchema, mapFieldToColumn, mapStringToColumn, pageQuerySchema, pageSchema, pg, schema, schemaToPgColumns, sql, updateSchema };
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DrizzleKitProvider, Entity, EntityDescriptorOptions, ExtractManyRelations, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_IDENTITY, PG_MANY, PG_ONE, PG_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgDefault, PgEntityNotFoundError, PgIdentityOptions, PgMany, PgManyOptions, PgOne, PgPrimaryKey, PgQuery, PgQueryWhere, PgQueryWhereOrSQL, PgQueryWhereWithMany, PgQueryWhereWithManyOrSQL, PgQueryWithMany, PgQueryWithMap, PgQueryWithOne, PgRef, PgRefOptions, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PostgresProvider, PostgresTypeProvider, RelField, RemoveManyRelations, RepositoryDescriptor, RepositoryDescriptorOptions, RepositoryProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, TPage, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle_orm6 as drizzle, insertSchema, legacyIdSchema, mapFieldToColumn, mapStringToColumn, pageQuerySchema, pageSchema, pg, schema, schemaToPgColumns, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map