alepha 0.7.7 → 0.8.1

package/postgres.d.ts

@@ -1,27 +1,26 @@
-import * as _alepha_core17 from "@alepha/core";
-import * as _alepha_core36 from "@alepha/core";
-import * as _alepha_core58 from "@alepha/core";
-import { Alepha, KIND, Module, OPTIONS, Static, TObject, TSchema as TSchema$1 } from "@alepha/core";
+import * as _alepha_core55 from "alepha";
+import * as _alepha_core19 from "alepha";
+import * as _alepha_core21 from "alepha";
+import { Alepha, KIND, Module, OPTIONS, Static, TObject, TSchema as TSchema$1 } from "alepha";
 import * as drizzle_orm3 from "drizzle-orm";
-import * as drizzle_orm71 from "drizzle-orm";
-import * as drizzle_orm1 from "drizzle-orm";
+import * as drizzle_orm8 from "drizzle-orm";
+import * as drizzle_orm2 from "drizzle-orm";
 import * as drizzle from "drizzle-orm";
 import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, TableConfig, sql } from "drizzle-orm";
-import * as _alepha_lock62 from "@alepha/lock";
+import * as _alepha_lock44 from "alepha/lock";
 import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import * as pg$1 from "drizzle-orm/pg-core";
-import * as drizzle_orm_pg_core76 from "drizzle-orm/pg-core";
-import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
+import * as drizzle_orm_pg_core13 from "drizzle-orm/pg-core";
+import * as drizzle_orm_pg_core1 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 * as _alepha_retry2 from "@alepha/retry";
-import * as _sinclair_typebox63 from "@sinclair/typebox";
-import * as _sinclair_typebox38 from "@sinclair/typebox";
+import * as _alepha_retry81 from "alepha/retry";
+import * as _sinclair_typebox74 from "@sinclair/typebox";
+import * as _sinclair_typebox89 from "@sinclair/typebox";
 import * as _sinclair_typebox85 from "@sinclair/typebox";
-import * as _sinclair_typebox88 from "@sinclair/typebox";
 import * as _sinclair_typebox82 from "@sinclair/typebox";
-import * as _sinclair_typebox19 from "@sinclair/typebox";
-import * as _sinclair_typebox10 from "@sinclair/typebox";
+import * as _sinclair_typebox57 from "@sinclair/typebox";
+import * as _sinclair_typebox48 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 { PgTransactionConfig as PgTransactionConfig$1 } from "drizzle-orm/pg-core/session";
 import * as DrizzleKit from "drizzle-kit/api";
@@ -29,9 +28,6 @@ import { MigrationConfig } from "drizzle-orm/migrator";
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 export * from "drizzle-orm/pg-core";
 
-//#region src/constants/PG_SCHEMA.d.ts
-declare const PG_SCHEMA: unique symbol;
-//#endregion
 //#region src/constants/PG_SYMBOLS.d.ts
 declare const PG_DEFAULT: unique symbol;
 declare const PG_PRIMARY_KEY: unique symbol;
@@ -83,6 +79,7 @@ interface PgRefOptions {
     onDelete?: UpdateDeleteAction;
   };
 }
+//# sourceMappingURL=PG_SYMBOLS.d.ts.map
 //#endregion
 //#region src/interfaces/TInsertObject.d.ts
 /**
@@ -273,96 +270,10 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject> = PgT
   get $schema(): R;
   get $insertSchema(): TInsertObject<R>;
 };
-//#endregion
-//#region src/descriptors/$entity.d.ts
-interface EntityDescriptorOptions<TTableName extends string, T extends TObject$1, Keys = keyof Static$1<T>> {
-  /**
-   * The name of the table. This is the name that will be used in the database.
-   * @example
-   * name: "user"
-   */
-  name: TTableName;
-  /**
-   * The schema of the table. This is a TypeBox schema that describes the columns and their types.
-   * @example
-   * schema: t.object({
-   *   id: t.uuid(),
-   *   name: t.string(),
-   *   email: t.string(),
-   *   phoneNumber: t.string(),
-   * })
-   */
-  schema: T;
-  /**
-   * The indexes to create for the table. This can be a string or an object with the column name and options.
-   * @example
-   * indexes: ["name", { column: "email", unique: true }]
-   */
-  indexes?: (Keys | {
-    column: Keys;
-    unique?: boolean;
-    name?: string;
-  } | {
-    columns: Keys[];
-    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>>;
-    foreignColumns: Array<AnyPgColumn>;
-  }>;
-  constraints?: Array<{
-    columns: Array<keyof Static$1<T>>;
-    name?: string;
-    unique?: boolean | {};
-    check?: SQL;
-  }>;
-  /**
-   * Extra configuration for the table. See drizzle-orm documentation for more details.
-   *
-   * @param self The table descriptor.
-   * @returns The extra configuration for the table.
-   */
-  config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
-}
-/**
- * Creates a table descriptor for drizzle-orm.
- */
-declare const $entity: <TTableName extends string, TSchema extends TObject$1, TColumnsMap extends FromSchema<TSchema>>(options: EntityDescriptorOptions<TTableName, TSchema>) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
-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";
-};
-//#endregion
-//#region src/providers/drivers/PostgresProvider.d.ts
-type SQLLike = SQLWrapper | string;
-declare class PostgresProvider {
-  constructor();
-  /**
-   * Get the database instance
-   */
-  get db(): PgDatabase<any>;
-  get schema(): string;
-  get dialect(): string;
-  execute(_query: SQLLike): Promise<any[]>;
+interface TableLike<T extends TObject = TObject> {
+  $schema: T;
 }
+//# sourceMappingURL=schemaToPgColumns.d.ts.map
 //#endregion
 //#region src/helpers/nullToUndefined.d.ts
 /**
@@ -377,6 +288,7 @@ 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/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
@@ -733,6 +645,7 @@ interface FilterOperators<TValue> {
    */
   arrayOverlaps?: TValue;
 }
+//# sourceMappingURL=FilterOperators.d.ts.map
 //#endregion
 //#region src/interfaces/InferInsert.d.ts
 /**
@@ -749,6 +662,7 @@ 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]> } & {
@@ -820,6 +734,7 @@ 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>)[] = []> {
@@ -848,14 +763,28 @@ type PgQueryWith<T extends TObject$1 | TArray> = true | {
     [key: string]: PgQueryWith<T>;
   };
 };
+//# sourceMappingURL=PgQuery.d.ts.map
+//#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$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_typebox63.TObject<{
-  page: _sinclair_typebox63.TOptional<_sinclair_typebox63.TNumber>;
-  size: _sinclair_typebox63.TOptional<_sinclair_typebox63.TNumber>;
-  sort: _sinclair_typebox63.TOptional<_sinclair_typebox63.TString>;
+declare const pageQuerySchema: _sinclair_typebox74.TObject<{
+  page: _sinclair_typebox74.TOptional<_sinclair_typebox74.TNumber>;
+  size: _sinclair_typebox74.TOptional<_sinclair_typebox74.TNumber>;
+  sort: _sinclair_typebox74.TOptional<_sinclair_typebox74.TString>;
 }>;
 type PageQuery = Static<typeof pageQuerySchema>;
+//# sourceMappingURL=pageQuerySchema.d.ts.map
 //#endregion
 //#region src/schemas/pageSchema.d.ts
 /**
@@ -893,6 +822,7 @@ type Page<T> = {
     countDuration?: number;
   };
 };
+//# sourceMappingURL=pageSchema.d.ts.map
 //#endregion
 //#region src/services/Repository.d.ts
 declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTableSchema extends TObject$1> {
@@ -901,7 +831,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
   protected readonly env: {
     POSTGRES_PAGINATION_COUNT_ENABLED: boolean;
   };
-  static of: <TEntity extends TableConfig$1, TSchema extends TObject$1>(opts: PgTableWithColumnsAndSchema<TEntity, TSchema$2>) => (new () => Repository<PgTableWithColumns<TEntity>, TSchema$2>);
+  static of: <TEntity extends TableConfig$1, TTableSchema_1 extends TObject$1>(opts: PgTableWithColumnsAndSchema<TEntity, TTableSchema_1>) => (new () => Repository<PgTableWithColumns<TEntity>, TTableSchema_1>);
   /**
    * Register Repository as a valid descriptor.
    * - Required for $repository to work.
@@ -950,8 +880,8 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
   /**
    * Getter for the database connection from the database provider.
    */
-  get db(): PgDatabase<any, Record<string, never>, drizzle_orm71.ExtractTablesWithRelations<Record<string, never>>>;
-  organization(): PgColumn;
+  protected get db(): PgDatabase<any, Record<string, never>, drizzle_orm8.ExtractTablesWithRelations<Record<string, never>>>;
+  protected organization(): PgColumn;
   /**
    * Execute a SQL query.
    *
@@ -978,29 +908,29 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
    *
    * @returns The SELECT query builder.
    */
-  protected select(opts?: StatementOptions): drizzle_orm_pg_core76.PgSelectBase<string, Record<string, PgColumn<drizzle_orm71.ColumnBaseConfig<drizzle_orm71.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+  protected select(opts?: StatementOptions): drizzle_orm_pg_core13.PgSelectBase<string, Record<string, PgColumn<drizzle_orm8.ColumnBaseConfig<drizzle_orm8.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
     [x: string]: unknown;
   }[], {
-    [x: string]: PgColumn<drizzle_orm71.ColumnBaseConfig<drizzle_orm71.ColumnDataType, string>, {}, {}>;
+    [x: string]: PgColumn<drizzle_orm8.ColumnBaseConfig<drizzle_orm8.ColumnDataType, string>, {}, {}>;
   }>;
   /**
    * Start an INSERT query on the table.
    *
    * @returns The INSERT query builder.
    */
-  protected insert(opts?: StatementOptions): drizzle_orm_pg_core76.PgInsertBuilder<TTable, any, false>;
+  protected insert(opts?: StatementOptions): drizzle_orm_pg_core13.PgInsertBuilder<TTable, any, false>;
   /**
    * Start an UPDATE query on the table.
    *
    * @returns The UPDATE query builder.
    */
-  protected update(opts?: StatementOptions): drizzle_orm_pg_core76.PgUpdateBuilder<TTable, any>;
+  protected update(opts?: StatementOptions): drizzle_orm_pg_core13.PgUpdateBuilder<TTable, any>;
   /**
    * Start a DELETE query on the table.
    *
    * @returns The DELETE query builder.
    */
-  protected delete(opts?: StatementOptions): drizzle_orm_pg_core76.PgDeleteBase<TTable, any, undefined, undefined, false, never>;
+  protected delete(opts?: StatementOptions): drizzle_orm_pg_core13.PgDeleteBase<TTable, any, undefined, undefined, false, never>;
   /**
    * Find entities.
    *
@@ -1114,7 +1044,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
    * @param schema The schema to use.
    * @param col The column to use.
    */
-  jsonQueryToSql(query: PgQueryWhere<Static$1<TTableSchema>>, schema?: TObject$1, col?: (key: string) => PgColumn): SQL | undefined;
+  protected jsonQueryToSql(query: PgQueryWhere<Static$1<TTableSchema>>, schema?: TObject$1, col?: (key: string) => PgColumn): SQL | undefined;
   /**
    * Map a filter operator to a SQL query.
    *
@@ -1158,7 +1088,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
    */
   protected getPrimaryKey(schema: TObject$1): {
     key: string;
-    col: PgColumn<drizzle_orm71.ColumnBaseConfig<drizzle_orm71.ColumnDataType, string>, {}, {}>;
+    col: PgColumn<drizzle_orm8.ColumnBaseConfig<drizzle_orm8.ColumnDataType, string>, {}, {}>;
     type: TSchema$2;
   };
 }
@@ -1192,28 +1122,134 @@ interface PgAttrField {
   data: any;
   nested?: any[];
 }
+//# sourceMappingURL=Repository.d.ts.map
 //#endregion
-//#region src/descriptors/$repository.d.ts
-interface RepositoryDescriptorOptions<TEntity extends TableConfig, TSchema extends TObject> {
+//#region src/constants/PG_SCHEMA.d.ts
+declare const PG_SCHEMA: unique symbol;
+//# sourceMappingURL=PG_SCHEMA.d.ts.map
+
+//#endregion
+//#region src/descriptors/$db.d.ts
+/**
+ * @experimental
+ */
+declare const $db: <T extends {
+  [key: string]: TableLike;
+}>(options?: DbDescriptorOptions<T>) => DbDescriptor<T>;
+type DbDescriptorOptions<T extends {
+  [key: string]: TableLike;
+}> = {
+  entities?: T;
+};
+type DbDescriptor<T extends {
+  [key: string]: TableLike;
+}> = { [key in keyof T]: Repository<any, T[key]["$schema"]> } & Pick<PostgresProvider, "execute">;
+//# sourceMappingURL=$db.d.ts.map
+//#endregion
+//#region src/descriptors/$entity.d.ts
+/**
+ * Creates a table descriptor for drizzle-orm.
+ */
+declare const $entity: <TTableName extends string, TSchema extends TObject$1, TColumnsMap extends FromSchema<TSchema>>(options: EntityDescriptorOptions<TTableName, TSchema>) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
+interface EntityDescriptorOptions<TTableName extends string, T extends TObject$1, Keys = keyof Static$1<T>> {
   /**
-   * The table to create the repository for.
+   * The name of the table. This is the name that will be used in the database.
+   * @example
+   * name: "user"
    */
-  table: PgTableWithColumnsAndSchema<TEntity, TSchema>;
+  name: TTableName;
   /**
-   * Override default provider.
+   * The schema of the table. This is a TypeBox schema that describes the columns and their types.
+   * @example
+   * schema: t.object({
+   *   id: t.uuid(),
+   *   name: t.string(),
+   *   email: t.string(),
+   *   phoneNumber: t.string(),
+   * })
    */
-  provider?: () => PostgresProvider;
+  schema: T;
+  /**
+   * The indexes to create for the table. This can be a string or an object with the column name and options.
+   * @example
+   * indexes: ["name", { column: "email", unique: true }]
+   */
+  indexes?: (Keys | {
+    column: Keys;
+    unique?: boolean;
+    name?: string;
+  } | {
+    columns: Keys[];
+    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>>;
+    foreignColumns: Array<AnyPgColumn>;
+  }>;
+  constraints?: Array<{
+    columns: Array<keyof Static$1<T>>;
+    name?: string;
+    unique?: boolean | {};
+    check?: SQL;
+  }>;
+  /**
+   * Extra configuration for the table. See drizzle-orm documentation for more details.
+   *
+   * @param self The table descriptor.
+   * @returns The extra configuration for the table.
+   */
+  config?: (self: BuildExtraConfigColumns<string, FromSchema<T>, "pg">) => PgTableExtraConfigValue[];
 }
+type Entity<T extends TObject$1> = PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
 /**
- * @param optionsOrTable
+ * 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/descriptors/$repository.d.ts
+/**
+ *
  */
 declare const $repository: {
   <TEntity extends TableConfig, TSchema extends TObject>(optionsOrTable: RepositoryDescriptorOptions<TEntity, TSchema> | PgTableWithColumnsAndSchema<TEntity, TSchema>): Repository<PgTableWithColumnsAndSchema<TEntity, TSchema>, TSchema>;
   [KIND]: string;
 };
+interface RepositoryDescriptorOptions<TEntity extends TableConfig, TSchema extends TObject> {
+  /**
+   * The table to create the repository for.
+   */
+  table: PgTableWithColumnsAndSchema<TEntity, TSchema>;
+  /**
+   * Override default provider.
+   */
+  provider?: () => PostgresProvider;
+}
+//# sourceMappingURL=$repository.d.ts.map
 //#endregion
 //#region src/descriptors/$sequence.d.ts
 declare const KEY = "SEQUENCE";
+declare const $sequence: {
+  (options?: SequenceDescriptorOptions): SequenceDescriptor;
+  [KIND]: string;
+};
 interface SequenceDescriptorOptions {
   name?: string;
   start?: number;
@@ -1229,18 +1265,18 @@ interface SequenceDescriptor {
   next(): Promise<number>;
   current(): Promise<number>;
 }
-declare const $sequence: {
-  (options?: SequenceDescriptorOptions): SequenceDescriptor;
-  [KIND]: string;
-};
 //#endregion
 //#region src/descriptors/$transaction.d.ts
+/**
+ *
+ */
+declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry81.RetryDescriptor<(...args: T) => Promise<R>>;
 interface TransactionDescriptorOptions<T extends any[], R> {
   handler: (tx: PgTransaction<any, any, any>, ...args: T) => Promise<R>;
   config?: PgTransactionConfig$1;
 }
 type TransactionContext = PgTransaction<any, any, any>;
-declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => _alepha_retry2.RetryDescriptor<(...args: T) => Promise<R>>;
+//# sourceMappingURL=$transaction.d.ts.map
 //#endregion
 //#region src/errors/EntityNotFoundError.d.ts
 declare class EntityNotFoundError extends Error {
@@ -1248,15 +1284,16 @@ declare class EntityNotFoundError extends Error {
   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_core17.Logger;
+  protected readonly log: _alepha_core55.Logger;
   protected readonly alepha: Alepha;
   protected readonly repositories: Array<Repository<any, TObject$1>>;
   constructor();
   clearRepositories(): Promise<void>;
-  protected readonly configure: _alepha_core17.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core55.HookDescriptor<"configure">;
   /**
    * Get all repositories.
    *
@@ -1286,10 +1323,11 @@ declare class RepositoryDescriptorProvider {
    */
   protected processRepositoryDescriptors(): Promise<void>;
 }
+//# sourceMappingURL=RepositoryDescriptorProvider.d.ts.map
 //#endregion
 //#region src/providers/DrizzleKitProvider.d.ts
 declare class DrizzleKitProvider {
-  protected readonly log: _alepha_core36.Logger;
+  protected readonly log: _alepha_core19.Logger;
   protected readonly alepha: Alepha;
   protected readonly repositoryProvider: RepositoryDescriptorProvider;
   push(provider: PostgresProvider, schema?: string): Promise<void>;
@@ -1321,51 +1359,52 @@ 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: _alepha_core58.TObject<{
-  PG_HOST: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  PG_USERNAME: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  PG_DATABASE: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  PG_PASSWORD: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  PG_PORT: _sinclair_typebox38.TOptional<_sinclair_typebox38.TNumber>;
-  DATABASE_URL: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
-  DATABASE_MIGRATIONS_FOLDER: _sinclair_typebox38.TString;
+declare const envSchema: TObject$1<{
+  PG_HOST: _alepha_core21.TOptional<_alepha_core21.TString>;
+  PG_USERNAME: _alepha_core21.TOptional<_alepha_core21.TString>;
+  PG_DATABASE: _alepha_core21.TOptional<_alepha_core21.TString>;
+  PG_PASSWORD: _alepha_core21.TOptional<_alepha_core21.TString>;
+  PG_PORT: _alepha_core21.TOptional<_alepha_core21.TNumber>;
+  DATABASE_URL: _alepha_core21.TOptional<_alepha_core21.TString>;
+  DATABASE_MIGRATIONS_FOLDER: _alepha_core21.TString;
   /**
    * The schema to use.
    * Accept a string.
    */
-  POSTGRES_SCHEMA: _sinclair_typebox38.TOptional<_sinclair_typebox38.TString>;
+  POSTGRES_SCHEMA: _alepha_core21.TOptional<_alepha_core21.TString>;
   /**
    * Synchronize the database schema with the models.
    * Accept a boolean or a postgres schema name.
    *
    * @default false
    */
-  POSTGRES_SYNCHRONIZE: _sinclair_typebox38.TOptional<_sinclair_typebox38.TBoolean>;
+  POSTGRES_SYNCHRONIZE: _alepha_core21.TOptional<_alepha_core21.TBoolean>;
   /**
    * Push the schema to the database.
    *
    * @default false
    */
-  POSTGRES_PUSH_SCHEMA: _sinclair_typebox38.TOptional<_sinclair_typebox38.TBoolean>;
+  POSTGRES_PUSH_SCHEMA: _alepha_core21.TOptional<_alepha_core21.TBoolean>;
   /**
    * Reject unauthorized SSL connections.
    *
    * @default false
    */
-  POSTGRES_REJECT_UNAUTHORIZED: _sinclair_typebox38.TBoolean;
+  POSTGRES_REJECT_UNAUTHORIZED: _alepha_core21.TBoolean;
 }>;
 interface NodePostgresProviderState {
   client: postgres.Sql;
   db: PostgresJsDatabase;
 }
-declare class NodePostgresProvider implements PostgresProvider {
+declare class NodePostgresProvider extends PostgresProvider {
   readonly dialect = "postgres";
-  protected readonly log: _alepha_core58.Logger;
+  protected readonly log: _alepha_core21.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
     PG_HOST?: string | undefined;
@@ -1387,16 +1426,16 @@ declare class NodePostgresProvider implements PostgresProvider {
    */
   protected testingSchemaName?: string;
   get db(): PostgresJsDatabase;
-  protected readonly configure: _alepha_core58.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core58.HookDescriptor<"stop">;
+  protected readonly configure: _alepha_core21.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core21.HookDescriptor<"stop">;
   /**
    * Get Postgres schema.
    */
   get schema(): string;
-  execute(query: SQLLike): Promise<any[]>;
+  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_lock62.LockDescriptor<() => Promise<void>>;
+  protected migrate: _alepha_lock44.LockDescriptor<() => Promise<void>>;
   protected createClient(): NodePostgresProviderState;
   protected getMigrationOptions(): MigrationConfig;
   protected getClientOptions(): postgres.Options<any>;
@@ -1411,16 +1450,21 @@ declare class NodePostgresProvider implements PostgresProvider {
 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_typebox85.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+declare const createdAtSchema: PgAttr<PgAttr<_sinclair_typebox89.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_typebox88.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<_sinclair_typebox85.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_typebox82.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+//# sourceMappingURL=updatedAtSchema.d.ts.map
+
 //#endregion
 //#region src/schemas/entitySchema.d.ts
 /**
@@ -1429,9 +1473,9 @@ declare const updatedAtSchema: PgAttr<PgAttr<_sinclair_typebox82.TString, typeof
  * Add some common SQL properties to an object.
  */
 declare const entitySchema: TObject$1<{
-  id: PgAttr<PgAttr<PgAttr<_sinclair_typebox19.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
-  createdAt: PgAttr<PgAttr<_sinclair_typebox19.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  updatedAt: PgAttr<PgAttr<_sinclair_typebox19.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  id: PgAttr<PgAttr<PgAttr<_sinclair_typebox57.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+  createdAt: PgAttr<PgAttr<_sinclair_typebox57.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  updatedAt: PgAttr<PgAttr<_sinclair_typebox57.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
 }>;
 /**
  * TypeBox Entity Type.
@@ -1453,9 +1497,10 @@ 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/core" {
+declare module "alepha" {
   interface TypeProvider {
     pg: PostgresTypeProvider;
   }
@@ -1465,20 +1510,19 @@ declare class PostgresTypeProvider {
   /**
    * Creates a primary key with an identity column.
    */
-  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox10.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: IntegerOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox48.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_typebox10.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox48.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
   /**
    * Creates a primary key with a UUID column.
    */
-  readonly uuidPrimaryKey: () => PgAttr<PgAttr<_sinclair_typebox10.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  readonly uuidPrimaryKey: () => PgAttr<PgAttr<_sinclair_typebox48.TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
   /**
-   *
    * @alias bigIdentityPrimaryKey
    */
-  readonly primaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox10.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  readonly primaryKey: (identity?: PgIdentityOptions, options?: NumberOptions) => PgAttr<PgAttr<PgAttr<_sinclair_typebox48.TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
   /**
    * Wrap a schema with "default" attribute.
    * This is used to set a default value for a column in the database.
@@ -1489,15 +1533,15 @@ declare class PostgresTypeProvider {
    * This is used to track the version of a row in the database.
    * You can use it for optimistic concurrency control.
    */
-  readonly version: (options?: IntegerOptions) => PgAttr<PgAttr<_sinclair_typebox10.TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  readonly version: (options?: IntegerOptions) => PgAttr<PgAttr<_sinclair_typebox48.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_typebox10.TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  readonly createdAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox48.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_typebox10.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  readonly updatedAt: (options?: StringOptions) => PgAttr<PgAttr<_sinclair_typebox48.TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
   /**
    * @deprecated Build your own entity schema.
    */
@@ -1537,12 +1581,13 @@ declare class PostgresTypeProvider {
   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>;
 }
 declare const pg: PostgresTypeProvider;
+//# sourceMappingURL=PostgresTypeProvider.d.ts.map
 //#endregion
 //#region src/types/schema.d.ts
 /**
  * Postgres schema type.
  */
-declare const schema: <TDocument extends TSchema$2>(name: string, document: TDocument) => drizzle_orm1.$Type<drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+declare const schema: <TDocument extends TSchema$2>(name: string, document: TDocument) => drizzle_orm2.$Type<drizzle_orm_pg_core1.PgCustomColumnBuilder<{
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
@@ -1554,8 +1599,139 @@ 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
+declare module "alepha" {
+  function $inject<T extends TableConfig, R extends TObject>(type: PgTableWithColumnsAndSchema<T, R>): Repository<PgTableWithColumnsAndSchema<T, R>, R>;
+}
+/**
+ * Provides PostgreSQL and SQLite database integration with type-safe ORM capabilities through Drizzle.
+ *
+ * The postgres module enables declarative database operations using descriptors like `$entity`, `$repository`,
+ * and `$db` on class properties. It offers automatic schema generation, type-safe queries, transactions,
+ * and database migrations with support for both PostgreSQL and SQLite backends.
+ *
+ * **Key Features:**
+ * - Declarative entity definition with `$entity` descriptor
+ * - Type-safe repository pattern with `$repository` descriptor
+ * - Database connection management with `$db` descriptor
+ * - Automatic schema migrations and type generation
+ * - Transaction support with `$transaction` descriptor
+ * - Sequence management with `$sequence` descriptor
+ * - Full TypeScript integration with compile-time type checking
+ *
+ * **Basic Usage:**
+ * ```ts
+ * import { Alepha, run, t } from "alepha";
+ * import { AlephaPostgres, $entity, $repository, pg } from "alepha/postgres";
+ *
+ * // Define database entities
+ * const user = $entity({
+ *   name: "users",
+ *   schema: t.object({
+ *     id: pg.primaryKey(),
+ *     createdAt: pg.createdAt(),
+ *     name: t.string(),
+ *     email: t.string(),
+ *     age: t.optional(t.integer()),
+ *   }),
+ * });
+ *
+ * const post = $entity({
+ *   name: "posts",
+ *   schema: t.object({
+ *     id: pg.primaryKey(),
+ *     createdAt: pg.createdAt(),
+ *     title: t.string(),
+ *     content: t.string(),
+ *     authorId: pg.references(t.uint(), () => user.id),
+ *   }),
+ * });
+ *
+ * class Database {
+ *   users = $repository(user);
+ *   posts = $repository(post);
+ * }
+ *
+ * const alepha = Alepha.create()
+ *   .with(AlephaPostgres)
+ *   .with(Database);
+ *
+ * run(alepha);
+ * ```
+ *
+ * **Repository Operations:**
+ * ```ts
+ * class UserService {
+ *   users = $repository(user);
+ *
+ *   async createUser(userData: { name: string; email: string }) {
+ *     return await this.users.create(userData);
+ *   }
+ *
+ *   async findUserByEmail(email: string) {
+ *     return await this.users.findFirst({
+ *       where: { email },
+ *     });
+ *   }
+ *
+ *   async getUsersWithPosts() {
+ *     return await this.users.find({
+ *       with: { posts: true },
+ *       limit: 10,
+ *     });
+ *   }
+ *
+ *   async updateUser(id: number, updates: Partial<{ name: string; age: number }>) {
+ *     return await this.users.update(id, updates);
+ *   }
+ * }
+ * ```
+ *
+ * **Advanced Database Operations:**
+ * ```ts
+ * import { $db, $transaction } from "alepha/postgres";
+ *
+ * class AdvancedDatabase {
+ *   db = $db({
+ *     entities: { user, post },
+ *   });
+ *
+ *   createUserWithPost = $transaction(async () => {
+ *     const newUser = await this.db.users.create({
+ *       name: "John Doe",
+ *       email: "john@example.com",
+ *     });
+ *
+ *     const newPost = await this.db.posts.create({
+ *       title: "My First Post",
+ *       content: "Hello world!",
+ *       authorId: newUser.id,
+ *     });
+ *
+ *     return { user: newUser, post: newPost };
+ *   });
+ *
+ *   async rawQuery() {
+ *     // Execute raw SQL queries
+ *     return await this.db.execute(sql`
+ *       SELECT users.name, COUNT(posts.id) as post_count
+ *       FROM users
+ *       LEFT JOIN posts ON users.id = posts.author_id
+ *       GROUP BY users.id, users.name
+ *     `);
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link $entity}
+ * @see {@link $repository}
+ * @see {@link $db}
+ * @see {@link $transaction}
+ * @module alepha.postgres
+ */
 declare class AlephaPostgres implements Module {
   readonly name = "alepha.postgres";
   readonly env: {
@@ -1563,6 +1739,8 @@ declare class AlephaPostgres implements Module {
   };
   readonly $services: (alepha: Alepha) => void;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#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, Repository, RepositoryDescriptorOptions, RepositoryDescriptorProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TEntity$1 as TEntity, TInsertObject, TPage, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle, entityKeys, entitySchema, mapFieldToColumn, mapStringToColumn, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToPgColumns, sql };
+export { $db, $entity, $repository, $sequence, $transaction, AlephaPostgres, BaseEntity, BaseEntityKeys, DbDescriptor, DbDescriptorOptions, 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, Repository, RepositoryDescriptorOptions, RepositoryDescriptorProvider, SQLLike, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TEntity$1 as TEntity, TInsertObject, TPage, TableLike, TransactionContext, TransactionDescriptorOptions, camelToSnakeCase, drizzle, entityKeys, entitySchema, mapFieldToColumn, mapStringToColumn, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToPgColumns, sql };
 //# sourceMappingURL=index.d.ts.map