alepha 0.9.2 → 0.9.4

package/postgres.d.ts

@@ -1,29 +1,17 @@
-import * as _alepha_core24 from "alepha";
-import * as _alepha_core0$1 from "alepha";
 import * as _alepha_core1 from "alepha";
-import * as _alepha_core0 from "alepha";
-import { Alepha, Descriptor, KIND, Service, Static, TObject, TSchema as TSchema$1 } from "alepha";
+import { Alepha, AlephaError, Descriptor, KIND, Service, Static, TObject, TSchema as TSchema$1 } from "alepha";
 import * as drizzle_orm7 from "drizzle-orm";
-import * as drizzle_orm0$1 from "drizzle-orm";
-import * as drizzle_orm0 from "drizzle-orm";
-import * as drizzle from "drizzle-orm";
 import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, TableConfig, sql } from "drizzle-orm";
 import * as pg$1 from "drizzle-orm/pg-core";
-import * as drizzle_orm_pg_core0$1 from "drizzle-orm/pg-core";
-import * as drizzle_orm_pg_core4 from "drizzle-orm/pg-core";
-import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
-import { AnyPgColumn, AnyPgTable, LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, PgTransactionConfig, TableConfig as TableConfig$1, UpdateDeleteAction } 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 { DateTimeProvider } from "alepha/datetime";
+import * as _alepha_logger1 from "alepha/logger";
 import * as _alepha_lock0 from "alepha/lock";
 import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import * as _alepha_retry0 from "alepha/retry";
-import * as _sinclair_typebox9 from "@sinclair/typebox";
-import * as _sinclair_typebox16 from "@sinclair/typebox";
-import * as _sinclair_typebox17 from "@sinclair/typebox";
-import * as _sinclair_typebox18 from "@sinclair/typebox";
-import * as _sinclair_typebox6 from "@sinclair/typebox";
-import * as _sinclair_typebox0 from "@sinclair/typebox";
-import { Evaluate, IntegerOptions, Kind, NumberOptions, ObjectOptions, OptionalKind, Static as Static$1, StringOptions, TAdditionalProperties, TArray, TBoolean, TInteger, TIntersect, TObject as TObject$1, TOptional, TOptionalWithFlag, TPick, TProperties, TReadonly, TRecord, TSchema as TSchema$2 } from "@sinclair/typebox";
+import * as _sinclair_typebox1 from "@sinclair/typebox";
+import { Evaluate, IntegerOptions, Kind, NumberOptions, ObjectOptions, OptionalKind, Static as Static$1, StringOptions, TAdditionalProperties, TArray, TBoolean, TInteger, TIntersect, TNumber, TObject as TObject$1, TOptional, TOptionalWithFlag, TPick, TProperties, TReadonly, TRecord, TSchema as TSchema$2, TString } from "@sinclair/typebox";
 import { PgTransactionConfig as PgTransactionConfig$1 } from "drizzle-orm/pg-core/session";
 import * as DrizzleKit from "drizzle-kit/api";
 import { MigrationConfig } from "drizzle-orm/migrator";
@@ -32,24 +20,21 @@ export * from "drizzle-orm/pg-core";
 
 //#region src/constants/PG_SCHEMA.d.ts
 declare const PG_SCHEMA: unique symbol;
-//# sourceMappingURL=PG_SCHEMA.d.ts.map
 //#endregion
 //#region src/constants/PG_SYMBOLS.d.ts
 declare const PG_DEFAULT: unique symbol;
 declare const PG_PRIMARY_KEY: unique symbol;
 declare const PG_CREATED_AT: unique symbol;
 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 PgRef = typeof PG_REF;
 type PgPrimaryKey = typeof PG_PRIMARY_KEY;
 type PgSymbols = {
@@ -57,10 +42,9 @@ type PgSymbols = {
   [PG_PRIMARY_KEY]: {};
   [PG_CREATED_AT]: {};
   [PG_UPDATED_AT]: {};
+  [PG_DELETED_AT]: {};
   [PG_VERSION]: {};
   [PG_IDENTITY]: PgIdentityOptions;
-  [PG_MANY]: PgManyOptions;
-  [PG_ONE]: PgManyOptions;
   [PG_REF]: PgRefOptions;
   /**
    * @deprecated Use `PG_IDENTITY` instead.
@@ -73,11 +57,6 @@ type PgIdentityOptions = {
 } & PgSequenceOptions & {
   name?: string;
 };
-interface PgManyOptions {
-  table: AnyPgTable;
-  schema: TObject$1;
-  foreignKey: string;
-}
 interface PgRefOptions {
   ref: () => AnyPgColumn;
   actions?: {
@@ -85,7 +64,6 @@ interface PgRefOptions {
     onDelete?: UpdateDeleteAction;
   };
 }
-//# sourceMappingURL=PG_SYMBOLS.d.ts.map
 //#endregion
 //#region src/interfaces/TInsertObject.d.ts
 /**
@@ -112,7 +90,7 @@ type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProp
 //#endregion
 //#region src/helpers/schemaToPgColumns.d.ts
 /**
- * Convert a Typebox Schema to Drizzle ORM Postgres columns (yes)
+ * Convert a Typebox Schema to Drizzle ORM Postgres columns
  */
 declare const schemaToPgColumns: <T extends TObject>(schema: T) => FromSchema<T>;
 /**
@@ -122,7 +100,7 @@ declare const schemaToPgColumns: <T extends TObject>(schema: T) => FromSchema<T>
  * @param value The value of the field.
  * @returns The PG column.
  */
-declare const mapFieldToColumn: (name: string, value: TSchema$1) => pg$1.PgSerialBuilderInitial<string> | pg$1.PgIntegerBuilderInitial<string> | drizzle_orm7.IsIdentity<pg$1.PgBigInt53BuilderInitial<"">, "always"> | pg$1.PgNumericBuilderInitial<string> | pg$1.PgTimestampBuilderInitial<string> | pg$1.PgUUIDBuilderInitial<string> | pg$1.PgCustomColumnBuilder<{
+declare const mapFieldToColumn: (name: string, value: TSchema$1) => pg$1.PgSerialBuilderInitial<string> | pg$1.PgIntegerBuilderInitial<string> | pg$1.PgBigInt53BuilderInitial<string> | pg$1.PgNumericBuilderInitial<string> | pg$1.PgTimestampBuilderInitial<string> | pg$1.PgUUIDBuilderInitial<string> | pg$1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -279,11 +257,30 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
 interface TableLike<T extends TObject = TObject> {
   $schema: T;
 }
-//# sourceMappingURL=schemaToPgColumns.d.ts.map
 //#endregion
 //#region src/descriptors/$entity.d.ts
 /**
- * Creates a table descriptor for drizzle-orm.
+ * Declare a new entity in the database.
+ * This descriptor alone does not create the table, it only describes it.
+ * It must be used with `$repository` to create the table and perform operations on it.
+ *
+ * This is a convenience function to create a table with a json schema.
+ * For now, it creates a drizzle-orm table under the hood.
+ * ```ts
+ * import { $entity } from "alepha/postgres";
+ *
+ * const User = $entity({
+ *   name: "user",
+ *   schema: t.object({
+ *     id: pg.primaryKey(t.uuid()),
+ *     name: t.string(),
+ *     email: t.string(),
+ *   }),
+ *   indexes: ["email"],
+ * });
+ * ```
+ *
+ * @stability 2
  */
 declare const $entity: {
   <TTableName extends string, TSchema extends TObject$1, TColumnsMap extends FromSchema<TSchema>>(options: EntityDescriptorOptions<TTableName, TSchema>): PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
@@ -321,11 +318,6 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject$1
     unique?: boolean;
     name?: string;
   })[];
-  relations?: Record<string, {
-    type: "one" | "many";
-    table: () => any;
-    foreignColumn?: keyof Static$1<T>;
-  }>;
   foreignKeys?: Array<{
     name?: string;
     columns: Array<keyof Static$1<T>>;
@@ -346,25 +338,23 @@ interface EntityDescriptorOptions<TTableName extends string, T extends TObject$1
   config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
 type Entity<T extends TObject$1> = PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
-/**
- * Create a table with a json schema.
- *
- * @param name The name of the table.
- * @param schema The json schema of the table.
- * @param extraConfig Extra configuration for the table.
- */
-declare const pgTableSchema: <TTableName extends string, TSchema extends TObject$1, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
 type PgTableConfig<TTableName extends string, TSchema extends TObject$1, TColumnsMap extends FromSchema<TSchema>> = {
   name: TTableName;
   schema: any;
   columns: BuildColumns<TTableName, TColumnsMap, "pg">;
   dialect: "pg";
 };
-//# sourceMappingURL=$entity.d.ts.map
+//#endregion
+//#region src/errors/PgError.d.ts
+declare class PgError extends AlephaError {
+  name: string;
+  constructor(message: string, cause?: unknown);
+}
 //#endregion
 //#region src/helpers/nullToUndefined.d.ts
 /**
  * Replaces all null values in an object with undefined.
+ * We need this for converting all nulls from Drizzle outputs.
  *
  * @param value - The object to be processed.
  * @return A new object with all null values replaced with undefined.
@@ -375,7 +365,18 @@ declare const nullToUndefined: <T extends object>(value: T) => NullToUndefined<T
  */
 type NullToUndefined<T> = T extends null ? undefined : T extends null | undefined | string | number | boolean | symbol | bigint | Function | Date | RegExp ? T : T extends Array<infer U> ? Array<NullToUndefined<U>> : T extends Map<infer K, infer V> ? Map<K, NullToUndefined<V>> : T extends Set<infer U> ? Set<NullToUndefined<U>> : T extends object ? { [K in keyof T]: NullToUndefined<T[K]> } : unknown;
 type NullifyIfOptional<T> = { [K in keyof T]: undefined extends T[K] ? T[K] | null : T[K] };
-//# sourceMappingURL=nullToUndefined.d.ts.map
+//#endregion
+//#region src/helpers/pgAttr.d.ts
+/**
+ * Type representation.
+ */
+type PgAttr<T extends TSchema$1, TAttr extends PgSymbolKeys> = T & { [K in TAttr]: PgSymbols[K] };
+interface PgAttrField {
+  key: string;
+  type: TSchema$1;
+  data: any;
+  nested?: any[];
+}
 //#endregion
 //#region src/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
@@ -732,7 +733,6 @@ interface FilterOperators<TValue> {
    */
   arrayOverlaps?: TValue;
 }
-//# sourceMappingURL=FilterOperators.d.ts.map
 //#endregion
 //#region src/interfaces/InferInsert.d.ts
 /**
@@ -749,10 +749,10 @@ type StaticEntry<T extends TObject$1> = { [K in keyof T["properties"] as T["prop
 } | {
   [OptionalKind]: "Optional";
 } ? never : K]: Static$1<T["properties"][K]> };
-//# sourceMappingURL=InferInsert.d.ts.map
 //#endregion
 //#region src/interfaces/PgQueryWhere.d.ts
-type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key]> } & {
+type PgQueryWhereOrSQL<T extends object> = SQLWrapper | PgQueryWhere<T>;
+type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key]> | T[Key] } & {
   /**
    * Combine a list of conditions with the `and` operator. Conditions
    * that are equal `undefined` are automatically ignored.
@@ -769,7 +769,7 @@ type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key
    *   )
    * ```
    */
-  and?: Array<PgQueryWhere<T> | SQL>;
+  and?: Array<PgQueryWhereOrSQL<T>>;
   /**
    * Combine a list of conditions with the `or` operator. Conditions
    * that are equal `undefined` are automatically ignored.
@@ -786,7 +786,7 @@ type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key
    *   )
    * ```
    */
-  or?: Array<PgQueryWhere<T> | SQL>;
+  or?: Array<PgQueryWhereOrSQL<T>>;
   /**
    * Negate the meaning of an expression using the `not` keyword.
    *
@@ -798,7 +798,7 @@ type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key
    *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
    * ```
    */
-  not?: PgQueryWhere<T>;
+  not?: PgQueryWhereOrSQL<T>;
   /**
    * Test whether a subquery evaluates to have any rows.
    *
@@ -821,36 +821,18 @@ type PgQueryWhere<T extends object> = { [Key in keyof T]?: FilterOperators<T[Key
    */
   exists?: SQLWrapper;
 };
-//# sourceMappingURL=PgQueryWhere.d.ts.map
 //#endregion
 //#region src/interfaces/PgQuery.d.ts
 interface PgQuery<T extends TObject$1, Select extends (keyof Static$1<T>)[] = []> {
   columns?: Select;
   distinct?: boolean;
-  where?: PgQueryWhereWithMany<T> | SQLWrapper;
+  where?: PgQueryWhereOrSQL<Static$1<T>>;
   limit?: number;
   offset?: number;
   sort?: { [key in keyof Static$1<T>]?: "asc" | "desc" };
   groupBy?: (keyof Static$1<T>)[];
-  relations?: PgQueryWithMap<T>;
 }
 type PgQueryResult<T extends TObject$1, Select extends (keyof Static$1<T>)[]> = TPick<T, Select>;
-type PgQueryWhereWithMany<T extends TObject$1> = PgQueryWhere<Static$1<RemoveManyRelations<T>>> & ExtractManyRelations<T>;
-type ExtractManyRelations<T extends TObject$1> = { [K in keyof T["properties"] as T["properties"][K] extends {
-  [PG_MANY]: any;
-} ? T["properties"][K] extends TArray ? T["properties"][K]["items"] extends TObject$1 ? K : never : never : never]?: PgQueryWhere<Static$1<T["properties"][K]["items"]>> };
-type RemoveManyRelations<T extends TObject$1> = TObject$1<{ [K in keyof T["properties"] as T["properties"][K] extends {
-  [PG_MANY]: any;
-} ? never : K]: T["properties"][K] }>;
-type PgQueryWithMap<T extends TObject$1> = { [K in keyof T["properties"] as T["properties"][K] extends {
-  [PG_MANY]: any;
-} ? K : never]?: T["properties"][K] extends TObject$1 ? PgQueryWith<T["properties"][K]> : T["properties"][K] extends TArray ? PgQueryWith<T["properties"][K]> : never };
-type PgQueryWith<T extends TObject$1 | TArray> = true | {
-  relations?: {
-    [key: string]: PgQueryWith<T>;
-  };
-};
-//# sourceMappingURL=PgQuery.d.ts.map
 //#endregion
 //#region src/providers/drivers/PostgresProvider.d.ts
 type SQLLike = SQLWrapper | string;
@@ -860,18 +842,15 @@ declare abstract class PostgresProvider {
   abstract get schema(): string;
   abstract get dialect(): string;
   abstract execute<T extends TObject$1 = any>(query: SQLLike, schema?: T): Promise<Array<T extends TObject$1 ? Static$1<T> : any>>;
-  mapResult<T extends TObject$1 = any>(result: Array<any>, schema?: T): Array<T extends TObject$1 ? Static$1<T> : any>;
 }
-//# sourceMappingURL=PostgresProvider.d.ts.map
 //#endregion
 //#region src/schemas/pageQuerySchema.d.ts
-declare const pageQuerySchema: _sinclair_typebox9.TObject<{
-  page: _sinclair_typebox9.TOptional<_sinclair_typebox9.TNumber>;
-  size: _sinclair_typebox9.TOptional<_sinclair_typebox9.TNumber>;
-  sort: _sinclair_typebox9.TOptional<_sinclair_typebox9.TString>;
+declare const pageQuerySchema: _sinclair_typebox1.TObject<{
+  page: _sinclair_typebox1.TOptional<_sinclair_typebox1.TNumber>;
+  size: _sinclair_typebox1.TOptional<_sinclair_typebox1.TNumber>;
+  sort: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
 }>;
 type PageQuery = Static<typeof pageQuerySchema>;
-//# sourceMappingURL=pageQuerySchema.d.ts.map
 //#endregion
 //#region src/schemas/pageSchema.d.ts
 /**
@@ -909,11 +888,10 @@ type Page<T> = {
     countDuration?: number;
   };
 };
-//# sourceMappingURL=pageSchema.d.ts.map
 //#endregion
 //#region src/descriptors/$repository.d.ts
 /**
- *
+ * @stability 3
  */
 declare const $repository: {
   <EntityTableConfig extends TableConfig, EntitySchema extends TObject$1>(optionsOrTable: RepositoryDescriptorOptions<EntityTableConfig, EntitySchema> | PgTableWithColumnsAndSchema<EntityTableConfig, EntitySchema>): RepositoryDescriptor<EntityTableConfig, EntitySchema>;
@@ -930,13 +908,11 @@ interface RepositoryDescriptorOptions<EntityTableConfig extends TableConfig, Ent
   provider?: Service<PostgresProvider>;
 }
 declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, EntitySchema extends TObject$1> extends Descriptor<RepositoryDescriptorOptions<EntityTableConfig, EntitySchema>> {
+  protected readonly dateTimeProvider: DateTimeProvider;
   readonly provider: PostgresProvider;
   protected readonly alepha: Alepha;
   readonly schema: EntitySchema;
-  readonly insertSchema: TInsertObject<EntitySchema>;
-  protected readonly env: {
-    POSTGRES_PAGINATION_COUNT_ENABLED: boolean;
-  };
+  readonly schemaInsert: TInsertObject<EntitySchema>;
   /**
    * Represents the primary key of the table.
    * - Key is the name of the primary key column.
@@ -960,15 +936,11 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   /**
    * Getter for the database connection from the database provider.
    */
-  protected get db(): PgDatabase<any, Record<string, never>, drizzle_orm0$1.ExtractTablesWithRelations<Record<string, never>>>;
-  protected organization(): PgColumn;
+  protected get db(): PgDatabase<any, Record<string, never>, drizzle_orm7.ExtractTablesWithRelations<Record<string, never>>>;
   /**
    * Execute a SQL query.
-   *
-   * @param query
-   * @param schema
    */
-  execute<T extends TObject$1 = EntitySchema>(query: SQLLike | ((table: PgTableWithColumns<EntityTableConfig>, db: PgDatabase<any>) => SQLLike), schema?: T): Promise<Static$1<T>[]>;
+  query<T extends TObject$1 = EntitySchema>(query: SQLLike | ((table: PgTableWithColumns<EntityTableConfig>, db: PgDatabase<any>) => SQLLike), schema?: T): Promise<Static$1<T>[]>;
   /**
    * Get a Drizzle column from the table by his name.
    *
@@ -988,29 +960,34 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    *
    * @returns The SELECT query builder.
    */
-  protected select(opts?: StatementOptions): drizzle_orm_pg_core0$1.PgSelectBase<string, Record<string, PgColumn<drizzle_orm0$1.ColumnBaseConfig<drizzle_orm0$1.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+  protected select(opts?: StatementOptions): pg$1.PgSelectBase<string, Record<string, PgColumn<drizzle_orm7.ColumnBaseConfig<drizzle_orm7.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
     [x: string]: unknown;
   }[], {
-    [x: string]: PgColumn<drizzle_orm0$1.ColumnBaseConfig<drizzle_orm0$1.ColumnDataType, string>, {}, {}>;
+    [x: string]: PgColumn<drizzle_orm7.ColumnBaseConfig<drizzle_orm7.ColumnDataType, string>, {}, {}>;
+  }>;
+  protected selectDistinct(opts: StatementOptions | undefined, fields: SelectedFields): pg$1.PgSelectBase<string, SelectedFields, "partial", Record<string, "not-null">, false, never, {
+    [x: string]: unknown;
+  }[], {
+    [x: string]: never;
   }>;
   /**
    * Start an INSERT query on the table.
    *
    * @returns The INSERT query builder.
    */
-  protected insert(opts?: StatementOptions): drizzle_orm_pg_core0$1.PgInsertBuilder<PgTableWithColumns<EntityTableConfig>, any, false>;
+  protected insert(opts?: StatementOptions): pg$1.PgInsertBuilder<PgTableWithColumns<EntityTableConfig>, any, false>;
   /**
    * Start an UPDATE query on the table.
    *
    * @returns The UPDATE query builder.
    */
-  protected update(opts?: StatementOptions): drizzle_orm_pg_core0$1.PgUpdateBuilder<PgTableWithColumns<EntityTableConfig>, any>;
+  protected update(opts?: StatementOptions): pg$1.PgUpdateBuilder<PgTableWithColumns<EntityTableConfig>, any>;
   /**
    * Start a DELETE query on the table.
    *
    * @returns The DELETE query builder.
    */
-  protected delete(opts?: StatementOptions): drizzle_orm_pg_core0$1.PgDeleteBase<PgTableWithColumns<EntityTableConfig>, any, undefined, undefined, false, never>;
+  protected delete(opts?: StatementOptions): pg$1.PgDeleteBase<PgTableWithColumns<EntityTableConfig>, any, undefined, undefined, false, never>;
   /**
    * Find entities.
    *
@@ -1029,20 +1006,14 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
   findOne<T extends Static$1<EntitySchema> = Static$1<EntitySchema>>(where: PgQueryWhere<T>, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
   /**
    * Find an entity by ID.
-   *
-   * @param id
-   * @param opts
    */
   findById(id: string | number, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
   /**
    * Paginate entities.
-   *
-   * @param pageQuery The pagination query.
-   * @param findQuery The find query.
-   * @param opts The statement options.
-   * @returns The paginated entities.
    */
-  paginate(pageQuery?: PageQuery, findQuery?: PgQuery<EntitySchema>, opts?: StatementOptions): Promise<Page<Static$1<EntitySchema>>>;
+  paginate(pagination?: PageQuery, query?: PgQuery<EntitySchema>, opts?: StatementOptions & {
+    skipCount?: boolean;
+  }): Promise<Page<Static$1<EntitySchema>>>;
   createQuery(query?: PgQuery<EntitySchema>): PgQuery<EntitySchema>;
   createQueryWhere(where?: PgQueryWhere<Static$1<EntitySchema>>): PgQueryWhere<Static$1<EntitySchema>>;
   /**
@@ -1062,61 +1033,72 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    */
   createMany(values: Array<InferInsert<EntitySchema>>, opts?: StatementOptions): Promise<Static$1<EntitySchema>[]>;
   /**
-   * Update an entity.
-   *
-   * @param query The where clause.
-   * @param data The data to update.
-   * @param opts The statement options.
-   * @returns The updated entity.
+   * Find an entity and update it.
    */
-  updateOne(query: PgQueryWhere<Static$1<EntitySchema>>, data: Partial<NullifyIfOptional<Static$1<EntitySchema>>> | {
-    $append: Partial<NullifyIfOptional<Static$1<EntitySchema>>>;
-  }, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
-  save(data: InferInsert<EntitySchema>, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
+  updateOne(where: PgQueryWhereOrSQL<Static$1<EntitySchema>>, data: Partial<NullifyIfOptional<Static$1<EntitySchema>>>, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
   /**
-   * Update an entity by ID.
+   * Save a given entity.
+   *
+   * @example
+   * ```ts
+   * const entity = await repository.findById(1);
+   * entity.name = "New Name";
+   * await repository.save(entity);
+   * ```
+   *
+   * Difference with `updateById/updateOne`:
+   *
+   * - requires the entity to be fetched first
+   * - check pg.version() if present - optimistic locking
+   * - validate entity against schema
    *
-   * @param id
-   * @param data
-   * @param opts
+   * @see {@link PostgresTypeProvider#version}
+   * @see {@link PgVersionMismatchError}
+   */
+  save(entity: Static$1<EntitySchema>, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
+  /**
+   * Find an entity by ID and update it.
    */
   updateById(id: string | number, data: Partial<NullifyIfOptional<Static$1<EntitySchema>>>, opts?: StatementOptions): Promise<Static$1<EntitySchema>>;
   /**
-   * Update entities.
-   *
-   * @param where The where clause.
-   * @param data The data to update.
-   * @param opts The statement options.
-   * @returns The updated entities.
+   * Find many entities and update all of them.
    */
-  updateMany(where: PgQueryWhere<Static$1<EntitySchema>>, data: Partial<NullifyIfOptional<Static$1<EntitySchema>>>, opts?: StatementOptions): Promise<Static$1<EntitySchema>[]>;
+  updateMany(where: PgQueryWhereOrSQL<Static$1<EntitySchema>>, data: Partial<NullifyIfOptional<Static$1<EntitySchema>>>, opts?: StatementOptions): Promise<void>;
   /**
-   * Delete entities.
-   *
-   * @param where Query.
-   * @param opts The statement options.
+   * Find many and delete all of them.
    */
   deleteMany(where?: PgQueryWhere<Static$1<EntitySchema>>, opts?: StatementOptions): Promise<void>;
   /**
    * Delete all entities.
-   * @param opts
    */
   clear(opts?: StatementOptions): Promise<void>;
   /**
-   * Delete an entity by ID.
+   * Delete the given entity.
    *
-   * @param id
-   * @param opts
+   * You must fetch the entity first in order to delete it.
+   */
+  destroy(entity: Static$1<EntitySchema>, opts?: StatementOptions): Promise<void>;
+  /**
+   * Find an entity and delete it.
+   */
+  deleteOne(where?: PgQueryWhere<Static$1<EntitySchema>>, opts?: StatementOptions): Promise<void>;
+  /**
+   * Find an entity by ID and delete it.
    */
   deleteById(id: string | number, opts?: StatementOptions): Promise<void>;
   /**
    * Count entities.
-   *
-   * @param where The where clause.
-   * @param opts The statement options.
-   * @returns The count of entities.
    */
-  count(where?: PgQueryWhere<Static$1<EntitySchema>>, opts?: StatementOptions): Promise<number>;
+  count(where?: PgQueryWhereOrSQL<Static$1<EntitySchema>>, opts?: StatementOptions): Promise<number>;
+  protected conflictMessagePattern: string;
+  protected handleError(error: unknown, message: string): PgError;
+  protected withDeletedAt(where: PgQueryWhereOrSQL<Static$1<EntitySchema>>, opts?: {
+    force?: boolean;
+  }): PgQueryWhereOrSQL<(EntitySchema & {
+    params: [];
+  })["static"]>;
+  protected get organization(): undefined;
+  protected deletedAt(): PgAttrField | undefined;
   /**
    * Convert a query object to a SQL query.
    *
@@ -1124,7 +1106,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param schema The schema to use.
    * @param col The column to use.
    */
-  protected jsonQueryToSql(query: PgQueryWhere<Static$1<EntitySchema>>, schema?: TObject$1, col?: (key: string) => PgColumn): SQL | undefined;
+  protected jsonQueryToSql(query: PgQueryWhereOrSQL<Static$1<EntitySchema>>, schema?: TObject$1, col?: (key: string) => PgColumn): SQL | undefined;
   /**
    * Map a filter operator to a SQL query.
    *
@@ -1132,7 +1114,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    * @param column
    * @protected
    */
-  protected mapOperatorToSql(operator: FilterOperators<any>, column: PgColumn): SQL | undefined;
+  protected mapOperatorToSql(operator: FilterOperators<any> | any, column: PgColumn): SQL | undefined;
   /**
    * Create a pagination object.
    *
@@ -1168,7 +1150,7 @@ declare class RepositoryDescriptor<EntityTableConfig extends TableConfig, Entity
    */
   protected getPrimaryKey(schema: TObject$1): {
     key: string;
-    col: PgColumn<drizzle_orm0$1.ColumnBaseConfig<drizzle_orm0$1.ColumnDataType, string>, {}, {}>;
+    col: PgColumn<drizzle_orm7.ColumnBaseConfig<drizzle_orm7.ColumnDataType, string>, {}, {}>;
     type: TSchema$2;
   };
 }
@@ -1188,23 +1170,15 @@ interface StatementOptions {
     strength: LockStrength;
   };
   /**
-   * Organization ID.
-   *
-   * Multi-tenant support.
-   *
-   * If set, it will be used to filter the results by organization.
+   * If true, ignore soft delete.
    */
-  organization?: string;
-}
-interface PgAttrField {
-  key: string;
-  type: TSchema$2;
-  data: any;
-  nested?: any[];
+  force?: boolean;
 }
-//# sourceMappingURL=$repository.d.ts.map
 //#endregion
 //#region src/descriptors/$sequence.d.ts
+/**
+ * @stability 1
+ */
 declare const $sequence: {
   (options?: SequenceDescriptorOptions): SequenceDescriptor;
   [KIND]: typeof SequenceDescriptor;
@@ -1225,11 +1199,10 @@ declare class SequenceDescriptor extends Descriptor<SequenceDescriptorOptions> {
   next(): Promise<number>;
   current(): Promise<number>;
 }
-//# sourceMappingURL=$sequence.d.ts.map
 //#endregion
 //#region src/descriptors/$transaction.d.ts
 /**
- *
+ * @stability 2
  */
 declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry0.RetryDescriptorFn<(...args: T) => Promise<R>>;
 interface TransactionDescriptorOptions<T extends any[], R> {
@@ -1237,23 +1210,19 @@ interface TransactionDescriptorOptions<T extends any[], R> {
   config?: PgTransactionConfig$1;
 }
 type TransactionContext = PgTransaction<any, any, any>;
-//# sourceMappingURL=$transaction.d.ts.map
 //#endregion
-//#region src/errors/EntityNotFoundError.d.ts
-declare class EntityNotFoundError extends Error {
-  readonly code = "ERR_RESOURCE_NOTFOUND";
+//#region src/errors/PgEntityNotFoundError.d.ts
+declare class PgEntityNotFoundError extends PgError {
+  readonly name = "EntityNotFoundError";
   readonly status = 404;
   constructor(entityName: string);
 }
-//# sourceMappingURL=EntityNotFoundError.d.ts.map
 //#endregion
-//#region src/providers/RepositoryDescriptorProvider.d.ts
-declare class RepositoryDescriptorProvider {
-  protected readonly log: _alepha_core24.Logger;
+//#region src/providers/RepositoryProvider.d.ts
+declare class RepositoryProvider {
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly alepha: Alepha;
-  get repositories(): RepositoryDescriptor<TableConfig$1, TObject$1>[];
-  constructor();
-  clearRepositories(): Promise<void>;
+  protected get repositories(): RepositoryDescriptor<TableConfig$1, TObject$1>[];
   /**
    * Get all repositories.
    *
@@ -1265,20 +1234,20 @@ declare class RepositoryDescriptorProvider {
    *
    * @param provider
    */
-  getTables(provider?: PostgresProvider): drizzle_orm_pg_core4.PgTableWithColumns<TableConfig$1>[];
+  getTables(provider?: PostgresProvider): pg$1.PgTableWithColumns<TableConfig$1>[];
   /**
-   * Get all providers from the repositories.
+   * Get all pg providers from the repositories.
    */
   getProviders(): PostgresProvider[];
 }
-//# sourceMappingURL=RepositoryDescriptorProvider.d.ts.map
 //#endregion
 //#region src/providers/DrizzleKitProvider.d.ts
 declare class DrizzleKitProvider {
-  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly alepha: Alepha;
-  protected readonly repositoryProvider: RepositoryDescriptorProvider;
+  protected readonly repositoryProvider: RepositoryProvider;
   push(provider: PostgresProvider, schema?: string): Promise<void>;
+  setPgSchema(provider: PostgresProvider): Promise<void>;
   /**
    * Try to generate migrations from scratch based on the models.
    * Then, execute the migrations.
@@ -1307,146 +1276,106 @@ declare class DrizzleKitProvider {
    */
   protected importDrizzleKit(): Promise<typeof DrizzleKit>;
 }
-//# sourceMappingURL=DrizzleKitProvider.d.ts.map
 //#endregion
 //#region src/providers/drivers/NodePostgresProvider.d.ts
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 declare const envSchema: TObject$1<{
-  PG_HOST: _alepha_core1.TOptional<_alepha_core1.TString>;
-  PG_USERNAME: _alepha_core1.TOptional<_alepha_core1.TString>;
-  PG_DATABASE: _alepha_core1.TOptional<_alepha_core1.TString>;
-  PG_PASSWORD: _alepha_core1.TOptional<_alepha_core1.TString>;
-  PG_PORT: _alepha_core1.TOptional<_alepha_core1.TNumber>;
+  /**
+   * Main configuration for database connection.
+   * Accept a string in the format of a Postgres connection URL.
+   * Example: postgres://user:password@localhost:5432/database
+   * or
+   * Example: postgres://user:password@localhost:5432/database?sslmode=require
+   */
   DATABASE_URL: _alepha_core1.TOptional<_alepha_core1.TString>;
-  DATABASE_MIGRATIONS_FOLDER: _alepha_core1.TString;
   /**
-   * The schema to use.
-   * Accept a string.
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   *
+   * It will monkey patch drizzle tables.
    */
   POSTGRES_SCHEMA: _alepha_core1.TOptional<_alepha_core1.TString>;
   /**
    * Synchronize the database schema with the models.
-   * Accept a boolean or a postgres schema name.
+   * It uses a custom implementation, it's not related to `drizzle-kit push` command.
+   * It will generate the migration script and save it to the DB.
+   *
+   * This is recommended for development and testing purposes only.
    *
    * @default false
    */
   POSTGRES_SYNCHRONIZE: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
   /**
    * Push the schema to the database.
+   * It's like `drizzle-kit push` command.
+   * It will introspect the models from DB and generate the SQL statements to create or update the tables.
    *
    * @default false
    */
-  POSTGRES_PUSH_SCHEMA: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
-  /**
-   * Reject unauthorized SSL connections.
-   *
-   * @default false
-   */
-  POSTGRES_REJECT_UNAUTHORIZED: _alepha_core1.TBoolean;
+  POSTGRES_PUSH: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
 }>;
-interface NodePostgresProviderState {
-  client: postgres.Sql;
-  db: PostgresJsDatabase;
+interface NodePostgresProviderOptions {
+  migrations: MigrationConfig;
+  connection: postgres.Options<any>;
 }
 declare class NodePostgresProvider extends PostgresProvider {
   readonly dialect = "postgres";
-  protected readonly log: _alepha_core1.Logger;
+  protected readonly sslModes: readonly ["require", "allow", "prefer", "verify-full"];
+  protected readonly log: _alepha_logger1.Logger;
   protected readonly env: {
-    PG_HOST?: string | undefined;
-    PG_USERNAME?: string | undefined;
-    PG_DATABASE?: string | undefined;
-    PG_PASSWORD?: string | undefined;
-    PG_PORT?: number | undefined;
     DATABASE_URL?: string | undefined;
     POSTGRES_SCHEMA?: string | undefined;
     POSTGRES_SYNCHRONIZE?: boolean | undefined;
-    POSTGRES_PUSH_SCHEMA?: boolean | undefined;
-    DATABASE_MIGRATIONS_FOLDER: string;
-    POSTGRES_REJECT_UNAUTHORIZED: boolean;
+    POSTGRES_PUSH?: boolean | undefined;
   };
   protected readonly alepha: Alepha;
   protected readonly kit: DrizzleKitProvider;
-  protected state?: NodePostgresProviderState;
+  protected client?: postgres.Sql;
+  protected pg?: PostgresJsDatabase;
+  readonly options: NodePostgresProviderOptions;
   /**
    * In testing mode, the schema name will be generated and deleted after the test.
    */
-  protected testingSchemaName?: string;
-  get db(): PostgresJsDatabase;
-  protected readonly configure: _alepha_core1.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
+  protected schemaForTesting?: string;
   /**
    * Get Postgres schema.
    */
   get schema(): string;
+  get db(): PostgresJsDatabase;
+  protected readonly configure: _alepha_core1.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core1.HookDescriptor<"stop">;
   execute<T extends TObject$1 = any>(query: SQLLike, schema?: T): Promise<Array<T extends TObject$1 ? Static<T> : any>>;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrate: _alepha_lock0.LockDescriptor<() => Promise<void>>;
-  protected createClient(): NodePostgresProviderState;
+  protected createClient(): {
+    client: postgres.Sql<{}>;
+    db: PostgresJsDatabase<Record<string, never>> & {
+      $client: postgres.Sql<{}>;
+    };
+  };
+  /**
+   * Generate a minimal migration configuration.
+   */
   protected getMigrationOptions(): MigrationConfig;
+  /**
+   * Map the DATABASE_URL to postgres client options.
+   */
   protected getClientOptions(): postgres.Options<any>;
-  protected sslModes: readonly ["require", "allow", "prefer", "verify-full"];
-  protected ssl(url: URL | undefined): "require" | "allow" | "prefer" | "verify-full" | undefined;
+  protected ssl(url: URL): "require" | "allow" | "prefer" | "verify-full" | undefined;
+  /**
+   * 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$1 = any>(result: Array<any>, schema?: T): Array<T extends TObject$1 ? Static<T> : any>;
 }
 //#endregion
-//#region src/helpers/pgAttr.d.ts
-/**
- * Type representation.
- */
-type PgAttr<T extends TSchema$1, TAttr extends PgSymbolKeys> = T & { [K in TAttr]: PgSymbols[K] };
-//#endregion
-//#region src/schemas/createdAtSchema.d.ts
-declare const createdAtSchema: PgAttr<PgAttr<_sinclair_typebox16.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-//# sourceMappingURL=createdAtSchema.d.ts.map
-
-//#endregion
-//#region src/schemas/legacyIdSchema.d.ts
-/**
- * @deprecated Use `pg.primaryKey()` instead.
- */
-declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<_sinclair_typebox17.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
-//# sourceMappingURL=legacyIdSchema.d.ts.map
-//#endregion
-//#region src/schemas/updatedAtSchema.d.ts
-declare const updatedAtSchema: PgAttr<PgAttr<_sinclair_typebox18.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-//# sourceMappingURL=updatedAtSchema.d.ts.map
-
-//#endregion
-//#region src/schemas/entitySchema.d.ts
-/**
- * Entity Schema.
- *
- * Add some common SQL properties to an object.
- */
-declare const entitySchema: TObject$1<{
-  id: PgAttr<PgAttr<PgAttr<_sinclair_typebox6.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<_sinclair_typebox6.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<_sinclair_typebox6.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-}>;
-/**
- * TypeBox Entity Type.
- */
-type TEntity<T extends TProperties> = TObject$1<T & {
-  id: typeof legacyIdSchema;
-  createdAt: typeof createdAtSchema;
-  updatedAt: typeof updatedAtSchema;
-}>;
-/**
- * The base entity.
- */
-type BaseEntity = Static<typeof entitySchema>;
-/**
- *  The keys of the base entity.
- */
-type BaseEntityKeys = keyof BaseEntity;
-/**
- *  The keys of the base entity.
- */
-declare const entityKeys: readonly ["id", "createdAt", "updatedAt"];
-//# sourceMappingURL=entitySchema.d.ts.map
-//#endregion
 //#region src/providers/PostgresTypeProvider.d.ts
 declare module "alepha" {
   interface TypeProvider {
@@ -1458,84 +1387,89 @@ declare class PostgresTypeProvider {
   /**
    * Creates a primary key with an identity column.
    */
-  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox0.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
   /**
    * Creates a primary key with a big identity column. (default)
    */
-  readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox0.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
   /**
    * Creates a primary key with a UUID column.
    */
-  readonly uuidPrimaryKey: () => PgAttr<PgAttr<_sinclair_typebox0.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  readonly uuidPrimaryKey: () => PgAttr<PgAttr<TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
   /**
-   * @alias bigIdentityPrimaryKey
+   * Creates a primary key for a given type. Supports:
+   * - `t.int()` -> PG INT (default)
+   * - `t.bigint()` -> PG BIGINT
+   * - `t.uuid()` -> PG UUID
    */
-  readonly primaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox0.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  primaryKey(): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TString, options?: StringOptions): PgAttr<PgAttr<TString, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TInteger, options?: IntegerOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TNumber, options?: NumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TNumber, PgPrimaryKey>, PgDefault>;
   /**
    * Wrap a schema with "default" attribute.
    * This is used to set a default value for a column in the database.
    */
   readonly default: <T extends TSchema$2>(type: T, value?: Static$1<T>) => PgAttr<T, PgDefault>;
   /**
-   * Creates a column version.
+   * Creates a column 'version'.
+   *
    * This is used to track the version of a row in the database.
-   * You can use it for optimistic concurrency control.
+   *
+   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryDescriptor#save}.
+   *
+   * @see {@link RepositoryDescriptor#save}
+   * @see {@link PgVersionMismatchError}
    */
-  readonly version: (options?: IntegerOptions) => PgAttr<PgAttr<_sinclair_typebox0.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  readonly version: (options?: IntegerOptions) => PgAttr<PgAttr<TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
   /**
    * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
    */
-  readonly createdAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox0.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  readonly createdAt: (options?: StringOptions) => PgAttr<PgAttr<TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
   /**
    * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
    */
-  readonly updatedAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox0.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  readonly updatedAt: (options?: StringOptions) => PgAttr<PgAttr<TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
   /**
-   * @deprecated Build your own entity schema.
+   * Creates a column Deleted At for soft delete functionality.
+   * This is used to mark rows as deleted without actually removing them from the database.
+   * The column is nullable - NULL means not deleted, timestamp means deleted.
    */
-  readonly entity: <T extends TProperties>(properties: T, options?: ObjectOptions) => TEntity<T>;
+  readonly deletedAt: (options?: StringOptions) => PgAttr<_sinclair_typebox1.TOptional<TString>, typeof PG_DELETED_AT>;
   /**
-   * Creates an insert schema for a given object schema.
-   * - pg.default will be optional
-   */
-  readonly insert: <T extends TObject$1>(obj: T) => TInsertObject<T>;
-  /**
-   * @alias insert
-   */
-  readonly input: <T extends TObject$1>(obj: T) => TInsertObject<T>;
-  /**
-   * Creates a page schema for a given object schema.
-   */
-  readonly page: <T extends TObject$1>(resource: T, options?: ObjectOptions) => TPage<T>;
-  /**
-   * Creates a reference to another table or schema.
+   * Creates a reference to another table or schema. Basically a foreign key.
    */
   readonly ref: <T extends TSchema$2>(type: T, ref: () => any, actions?: {
     onUpdate?: UpdateDeleteAction$1;
     onDelete?: UpdateDeleteAction$1;
   }) => PgAttr<T, PgRef>;
   /**
-   * @alias ref
+   * Convert a schema to a schema for INSERT operations.
+   * It means that:
+   * - All pg.default() will be optional
+   *
+   * @internal
    */
-  references: <T extends TSchema$2>(type: T, ref: () => any, actions?: {
-    onUpdate?: UpdateDeleteAction$1;
-    onDelete?: UpdateDeleteAction$1;
-  }) => PgAttr<T, PgRef>;
+  readonly insert: <T extends TObject$1>(obj: T) => TInsertObject<T>;
   /**
-   * Creates a reference to another table or schema with a foreign key.
-   *
-   * @experimental
+   * Creates a page schema for a given object schema.
+   * It's used by {@link RepositoryDescriptor#paginate} method.
    */
-  readonly many: <T extends TObject$1, Config extends TableConfig$1>(table: PgTableWithColumnsAndSchema<Config, T>, foreignKey: keyof T["properties"]) => TOptionalWithFlag<PgAttr<PgAttr<TArray<T>, PgMany>, PgDefault>, true>;
+  readonly page: <T extends TObject$1>(resource: T, options?: ObjectOptions) => TPage<T>;
 }
 declare const pg: PostgresTypeProvider;
-//# sourceMappingURL=PostgresTypeProvider.d.ts.map
+//#endregion
+//#region src/schemas/legacyIdSchema.d.ts
+/**
+ * @deprecated Use `pg.primaryKey()` instead.
+ */
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<_sinclair_typebox1.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 //#endregion
 //#region src/types/schema.d.ts
 /**
  * Postgres schema type.
  */
-declare const schema: <TDocument extends TSchema$2>(name: string, document: TDocument) => drizzle_orm0.$Type<drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+declare const schema: <TDocument extends TSchema$2>(name: string, document: TDocument) => drizzle_orm7.$Type<pg$1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -1547,25 +1481,49 @@ declare const schema: <TDocument extends TSchema$2>(name: string, document: TDoc
 }>, (TDocument & {
   params: [];
 })["static"]>;
-//# sourceMappingURL=schema.d.ts.map
-
 //#endregion
 //#region src/index.d.ts
 /**
- * Provides PostgreSQL (and SQLite!) database integration with type-safe ORM capabilities through Drizzle.
+ * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
+ *
+ * ```ts
+ * const users = $entity({
+ *   name: "users",
+ *   schema: t.object({
+ *     id: pg.primaryKey(),
+ *     name: t.string(),
+ *     email: t.string(),
+ *   }),
+ * });
+ *
+ * class Db {
+ *   users = $repository(users);
+ * }
+ *
+ * const db = alepha.inject(Db);
+ * const user = await db.users.one({ name: { eq: "John Doe" } });
+ * ```
  *
- * The postgres module enables declarative database operations using descriptors like `$entity`, `$repository`.
- * It offers automatic schema generation, type-safe queries, transactions,
- * and database migrations with support for PostgreSQLs.
+ * This is not a full ORM, but rather a set of tools to work with Postgres databases in a type-safe way.
+ *
+ * It provides:
+ * - A type-safe way to define entities and repositories. (via `$entity` and `$repository`)
+ * - Custom query builders and filters.
+ * - Built-in special columns like `createdAt`, `updatedAt`, `deletedAt`, `version`.
+ * - Automatic JSONB support.
+ * - Automatic synchronization of entities with the database schema (for testing and development).
+ * - Fallback to raw SQL via Drizzle ORM `sql` function.
+ *
+ * Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
+ *
+ * Relations are **NOT SUPPORTED** yet. If you need relations, please use the `drizzle-orm` package directly.
  *
  * @see {@link $entity}
  * @see {@link $repository}
  * @see {@link $transaction}
  * @module alepha.postgres
  */
-declare const AlephaPostgres: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaPostgres: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BaseEntity, BaseEntityKeys, DrizzleKitProvider, Entity, EntityDescriptorOptions, EntityNotFoundError, ExtractManyRelations, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderState, NullToUndefined, NullifyIfOptional, PG_CREATED_AT, PG_DEFAULT, PG_IDENTITY, PG_MANY, PG_ONE, PG_PRIMARY_KEY, PG_REF, PG_SCHEMA, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttrField, PgDefault, PgIdentityOptions, PgMany, PgManyOptions, PgPrimaryKey, PgQuery, PgQueryResult, PgQueryWhere, PgQueryWhereWithMany, PgQueryWith, PgQueryWithMap, PgRef, PgRefOptions, PgSymbolKeys, PgSymbols, PgTableConfig, PgTableWithColumnsAndSchema, PostgresProvider, PostgresTypeProvider, RemoveManyRelations, RepositoryDescriptor, RepositoryDescriptorOptions, RepositoryDescriptorProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TEntity, TInsertObject, TPage, TableLike, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle, entityKeys, entitySchema, mapFieldToColumn, mapStringToColumn, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToPgColumns, sql };
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DrizzleKitProvider, Entity, EntityDescriptorOptions, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, NullToUndefined, NullifyIfOptional, 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, TInsertObject, TPage, TableLike, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle_orm7 as drizzle, legacyIdSchema, mapFieldToColumn, mapStringToColumn, nullToUndefined, pageQuerySchema, pageSchema, pg, schema, schemaToPgColumns, sql };
 //# sourceMappingURL=index.d.ts.map