alepha 0.6.9 → 0.7.0

package/postgres.d.ts

@@ -1,16 +1,16 @@
 import * as _alepha_core from '@alepha/core';
 import { TObject as TObject$1, Static as Static$1, Alepha, KIND, OPTIONS } from '@alepha/core';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TObject, Static, TSchema, ObjectOptions, Kind, TProperties, Evaluate, TReadonly, TOptional, TAdditionalProperties, OptionalKind, TArray, TIntersect, TRecord, TBoolean, TInteger, IntegerOptions, StringOptions, TOptionalWithFlag } from '@sinclair/typebox';
-import * as drizzle_orm from 'drizzle-orm';
-import { TableConfig, SQLWrapper, SQL, BuildColumns } from 'drizzle-orm';
+import { TObject, Static, TSchema, ObjectOptions, Kind, TProperties, Evaluate, TReadonly, TOptional, TAdditionalProperties, OptionalKind, TArray, TIntersect, TRecord, TBoolean, TInteger, TOptionalWithFlag, IntegerOptions, StringOptions } from '@sinclair/typebox';
+import * as drizzle_orm_query_builders_query_builder from 'drizzle-orm/query-builders/query-builder';
+import * as drizzleOrm from 'drizzle-orm';
+import { TableConfig, BuildExtraConfigColumns, SQLWrapper, SQL, BuildColumns } from 'drizzle-orm';
 export { sql } from 'drizzle-orm';
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { PgSequenceOptions, AnyPgTable, AnyPgColumn, UpdateDeleteAction, PgTableExtraConfigValue, PgTableWithColumns, PgColumnBuilderBase, PgDatabase, TableConfig as TableConfig$1, PgColumn, PgTransaction, PgTransactionConfig, LockStrength, LockConfig, PgInsertValue, PgSelectJoinFn } from 'drizzle-orm/pg-core';
+import { PgSequenceOptions, AnyPgTable, AnyPgColumn, UpdateDeleteAction, PgTableWithColumns, PgColumnBuilderBase, PgTableExtraConfigValue, PgDatabase, TableConfig as TableConfig$1, PgColumn, PgTransaction, PgTransactionConfig, LockStrength, LockConfig, PgInsertValue, PgSelectJoinFn } from 'drizzle-orm/pg-core';
 export * from 'drizzle-orm/pg-core';
 import { PgTransactionConfig as PgTransactionConfig$1 } from 'drizzle-orm/pg-core/session';
-import { BuildExtraConfigColumns } from 'drizzle-orm/column-builder';
-import { PgTableExtraConfigValue as PgTableExtraConfigValue$1 } from 'drizzle-orm/pg-core/table';
+import { BuildExtraConfigColumns as BuildExtraConfigColumns$1 } from 'drizzle-orm/column-builder';
 import * as _alepha_lock from '@alepha/lock';
 import { MigrationConfig } from 'drizzle-orm/migrator';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
@@ -67,28 +67,6 @@ interface PgRefOptions {
     };
 }
 
-interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
-    name: string;
-    schema: T;
-    indexes?: (Keys | {
-        column: Keys;
-        unique?: boolean;
-        name?: string;
-    })[];
-    foreignKeys?: {
-        columns: Keys[];
-        foreignTable: string;
-        foreignColumns: Keys[];
-        onUpdate?: "cascade" | "restrict" | "no action" | "set null" | "set default";
-        onDelete?: "cascade" | "restrict" | "no action" | "set null" | "set default";
-    }[];
-    config?: PgTableExtraConfigValue[];
-}
-/**
- * Creates a table descriptor for drizzle-orm.
- */
-declare const $entity: <T extends TObject>(options: EntityDescriptorOptions<T>) => PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
-
 /**
  * Convert a schema to columns.
  *
@@ -112,8 +90,50 @@ type PgTableWithColumnsAndSchema<T extends TableConfig, R extends TObject$1> = P
     [PG_SCHEMA]: R;
 };
 
+interface EntityDescriptorOptions<T extends TObject, Keys = keyof Static<T>> {
+    /**
+     * The name of the table. This is the name that will be used in the database.
+     * @example
+     * name: "user"
+     */
+    name: string;
+    /**
+     * 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;
+    })[];
+    /**
+     * 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: <T extends TObject>(options: EntityDescriptorOptions<T>) => PgTableWithColumnsAndSchema<PgTableConfig<string, T, FromSchema<T>>, T>;
+
 type SQLLike = SQLWrapper | string;
 declare class PostgresProvider {
+    constructor();
     /**
      * Get the database instance
      */
@@ -650,7 +670,7 @@ type PgQueryWith<T extends TObject | TArray> = true | {
 };
 
 declare const pageQuerySchema: _sinclair_typebox.TObject<{
-    page: _sinclair_typebox.TOptional<_sinclair_typebox.TInteger>;
+    page: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
     size: _sinclair_typebox.TOptional<_sinclair_typebox.TNumber>;
     sort: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
 }>;
@@ -675,6 +695,9 @@ type TPage<T extends TObject | TIntersect | TRecord> = TObject<{
     page: TObject<{
         number: TInteger;
         size: TInteger;
+        totalElements: TOptionalWithFlag<TInteger, true>;
+        queryDuration: TOptionalWithFlag<TInteger, true>;
+        countDuration: TOptionalWithFlag<TInteger, true>;
     }>;
 }>;
 /**
@@ -689,6 +712,9 @@ type Page<T> = {
     page: {
         number: number;
         size: number;
+        totalElements?: number;
+        queryDuration?: number;
+        countDuration?: number;
     };
 };
 
@@ -698,6 +724,9 @@ type Page<T> = {
 declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTableSchema extends TObject> {
     readonly provider: PostgresProvider;
     protected readonly alepha: Alepha;
+    protected readonly env: {
+        POSTGRES_PAGINATION_COUNT_ENABLED: boolean;
+    };
     static of: <TEntity extends TableConfig$1, TSchema extends TObject>(table: PgTableWithColumnsAndSchema<TEntity, TSchema>) => (new () => Repository<PgTableWithColumnsAndSchema<TEntity, TSchema>, TSchema>);
     /**
      * Register Repository as a valid descriptor.
@@ -747,7 +776,7 @@ 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_orm.ExtractTablesWithRelations<Record<string, never>>>;
+    get db(): PgDatabase<any, Record<string, never>, drizzleOrm.ExtractTablesWithRelations<Record<string, never>>>;
     /**
      *
      */
@@ -778,10 +807,10 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
      *
      * @returns The SELECT query builder.
      */
-    protected select(opts?: StatementOptions): drizzle_orm_pg_core.PgSelectBase<string, Record<string, PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
+    protected select(opts?: StatementOptions): drizzle_orm_pg_core.PgSelectBase<string, Record<string, PgColumn<drizzleOrm.ColumnBaseConfig<drizzleOrm.ColumnDataType, string>, {}, {}>>, "single", Record<string, "not-null">, false, never, {
         [x: string]: unknown;
     }[], {
-        [x: string]: PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>;
+        [x: string]: PgColumn<drizzleOrm.ColumnBaseConfig<drizzleOrm.ColumnDataType, string>, {}, {}>;
     }>;
     /**
      * Start an INSERT query on the table.
@@ -972,7 +1001,7 @@ declare class Repository<TTable extends PgTableWithColumns<TableConfig$1>, TTabl
      */
     protected getPrimaryKey(schema: TObject): {
         key: string;
-        col: PgColumn<drizzle_orm.ColumnBaseConfig<drizzle_orm.ColumnDataType, string>, {}, {}>;
+        col: PgColumn<drizzleOrm.ColumnBaseConfig<drizzleOrm.ColumnDataType, string>, {}, {}>;
         type: TSchema;
     };
     /**
@@ -1115,7 +1144,7 @@ type TransactionContext = PgTransaction<any, any, any>;
 /**
  * Creates a transaction descriptor.
  */
-declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => (...parameters: T) => Promise<Promise<R>>;
+declare const $transaction: <T extends any[], R>(opts: TransactionDescriptorOptions<T, R>) => (...parameters: T) => Promise<R>;
 
 declare class EntityNotFoundError extends Error {
     readonly code = "ERR_RESOURCE_NOTFOUND";
@@ -1130,16 +1159,7 @@ declare class EntityNotFoundError extends Error {
  * @param schema The json schema of the table.
  * @param extraConfig Extra configuration for the table.
  */
-declare const pgTableSchema: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
-/**
- * @alias pgTableSchema
- */
-declare const table: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
-declare const $table: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
-declare const table2: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue$1[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
-/**
- *
- */
+declare const pgTableSchema: <TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>>(name: TTableName, schema: TSchema, extraConfig?: (self: BuildExtraConfigColumns$1<TTableName, TColumnsMap, "pg">) => PgTableExtraConfigValue[]) => PgTableWithColumnsAndSchema<PgTableConfig<TTableName, TSchema, TColumnsMap>, TSchema>;
 type PgTableConfig<TTableName extends string, TSchema extends TObject, TColumnsMap extends FromSchema<TSchema>> = {
     name: TTableName;
     schema: any;
@@ -1420,7 +1440,7 @@ declare const pg: PostgresTypeProvider;
 /**
  * Postgres schema type.
  */
-declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm.$Type<drizzle_orm_pg_core.PgCustomColumnBuilder<{
+declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzleOrm.$Type<drizzle_orm_pg_core.PgCustomColumnBuilder<{
     name: string;
     dataType: "custom";
     columnType: "PgCustomColumn";
@@ -1433,6 +1453,176 @@ declare const schema: <TDocument extends TSchema>(name: string, document: TDocum
     params: [];
 })["static"]>;
 
+declare const dzl: {
+    pg: typeof drizzle_orm_pg_core;
+    aliasedTable<T extends drizzleOrm.Table | drizzleOrm.View>(table: T, tableAlias: string): T;
+    aliasedRelation<T extends drizzleOrm.Relation>(relation: T, tableAlias: string): T;
+    aliasedTableColumn<T extends drizzleOrm.AnyColumn>(column: T, tableAlias: string): T;
+    mapColumnsInAliasedSQLToAlias(query: drizzleOrm.SQL.Aliased, alias: string): drizzleOrm.SQL.Aliased;
+    mapColumnsInSQLToAlias(query: drizzleOrm.SQL, alias: string): drizzleOrm.SQL;
+    ColumnAliasProxyHandler: typeof drizzleOrm.ColumnAliasProxyHandler;
+    TableAliasProxyHandler: typeof drizzleOrm.TableAliasProxyHandler;
+    RelationTableAliasProxyHandler: typeof drizzleOrm.RelationTableAliasProxyHandler;
+    ColumnBuilder: typeof drizzleOrm.ColumnBuilder;
+    Column: typeof drizzleOrm.Column;
+    is<T extends drizzleOrm.DrizzleEntityClass<any>>(value: any, type: T): value is InstanceType<T>;
+    entityKind: typeof drizzleOrm.entityKind;
+    hasOwnEntityKind: typeof drizzleOrm.hasOwnEntityKind;
+    DrizzleError: typeof drizzleOrm.DrizzleError;
+    TransactionRollbackError: typeof drizzleOrm.TransactionRollbackError;
+    ConsoleLogWriter: typeof drizzleOrm.ConsoleLogWriter;
+    DefaultLogger: typeof drizzleOrm.DefaultLogger;
+    NoopLogger: typeof drizzleOrm.NoopLogger;
+    QueryPromise: typeof drizzleOrm.QueryPromise;
+    getOperators(): {
+        and: typeof drizzleOrm.and;
+        between: typeof drizzleOrm.between;
+        eq: drizzleOrm.BinaryOperator;
+        exists: typeof drizzleOrm.exists;
+        gt: drizzleOrm.BinaryOperator;
+        gte: drizzleOrm.BinaryOperator;
+        ilike: typeof drizzleOrm.ilike;
+        inArray: typeof drizzleOrm.inArray;
+        isNull: typeof drizzleOrm.isNull;
+        isNotNull: typeof drizzleOrm.isNotNull;
+        like: typeof drizzleOrm.like;
+        lt: drizzleOrm.BinaryOperator;
+        lte: drizzleOrm.BinaryOperator;
+        ne: drizzleOrm.BinaryOperator;
+        not: typeof drizzleOrm.not;
+        notBetween: typeof drizzleOrm.notBetween;
+        notExists: typeof drizzleOrm.notExists;
+        notLike: typeof drizzleOrm.notLike;
+        notIlike: typeof drizzleOrm.notIlike;
+        notInArray: typeof drizzleOrm.notInArray;
+        or: typeof drizzleOrm.or;
+        sql: typeof drizzleOrm.sql;
+    };
+    getOrderByOperators(): {
+        sql: typeof drizzleOrm.sql;
+        asc: typeof drizzleOrm.asc;
+        desc: typeof drizzleOrm.desc;
+    };
+    extractTablesRelationalConfig<TTables extends drizzleOrm.TablesRelationalConfig>(schema: Record<string, unknown>, configHelpers: (table: drizzleOrm.Table) => any): {
+        tables: TTables;
+        tableNamesMap: Record<string, string>;
+    };
+    relations<TTableName extends string, TRelations extends Record<string, drizzleOrm.Relation<any>>>(table: drizzleOrm.AnyTable<{
+        name: TTableName;
+    }>, relations: (helpers: drizzleOrm.TableRelationsHelpers<TTableName>) => TRelations): drizzleOrm.Relations<TTableName, TRelations>;
+    createOne<TTableName extends string>(sourceTable: drizzleOrm.Table): <TForeignTable extends drizzleOrm.Table, TColumns extends [drizzleOrm.AnyColumn<{
+        tableName: TTableName;
+    }>, ...drizzleOrm.AnyColumn<{
+        tableName: TTableName;
+    }>[]]>(table: TForeignTable, config?: drizzleOrm.RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns>) => drizzleOrm.One<TForeignTable["_"]["name"], drizzleOrm.Equal<TColumns[number]["_"]["notNull"], true>>;
+    createMany(sourceTable: drizzleOrm.Table): <TForeignTable extends drizzleOrm.Table>(referencedTable: TForeignTable, config?: {
+        relationName: string;
+    }) => drizzleOrm.Many<TForeignTable["_"]["name"]>;
+    normalizeRelation(schema: drizzleOrm.TablesRelationalConfig, tableNamesMap: Record<string, string>, relation: drizzleOrm.Relation): drizzleOrm.NormalizedRelation;
+    createTableRelationsHelpers<TTableName extends string>(sourceTable: drizzleOrm.AnyTable<{
+        name: TTableName;
+    }>): {
+        one: <TForeignTable extends drizzleOrm.Table, TColumns extends [drizzleOrm.AnyColumn<{
+            tableName: TTableName;
+        }>, ...drizzleOrm.AnyColumn<{
+            tableName: TTableName;
+        }>[]]>(table: TForeignTable, config?: drizzleOrm.RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns> | undefined) => drizzleOrm.One<TForeignTable["_"]["name"], drizzleOrm.Equal<TColumns[number]["_"]["notNull"], true>>;
+        many: <TForeignTable extends drizzleOrm.Table>(referencedTable: TForeignTable, config?: {
+            relationName: string;
+        }) => drizzleOrm.Many<TForeignTable["_"]["name"]>;
+    };
+    mapRelationalRow(tablesConfig: drizzleOrm.TablesRelationalConfig, tableConfig: drizzleOrm.TableRelationalConfig, row: unknown[], buildQueryResultSelection: drizzleOrm.BuildRelationalQueryResult["selection"], mapColumnValue?: (value: unknown) => unknown): Record<string, unknown>;
+    Relation: typeof drizzleOrm.Relation;
+    Relations: typeof drizzleOrm.Relations;
+    One: typeof drizzleOrm.One;
+    Many: typeof drizzleOrm.Many;
+    bindIfParam(value: unknown, column: drizzleOrm.SQLWrapper): drizzleOrm.SQLChunk;
+    and(...conditions: (drizzleOrm.SQLWrapper | undefined)[]): drizzleOrm.SQL | undefined;
+    or(...conditions: (drizzleOrm.SQLWrapper | undefined)[]): drizzleOrm.SQL | undefined;
+    not(condition: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    inArray<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    inArray<TColumn extends drizzleOrm.Column>(column: TColumn, values: ReadonlyArray<drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    inArray<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: ReadonlyArray<unknown | drizzleOrm.Placeholder> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notInArray<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notInArray<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notInArray<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    isNull(value: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    isNotNull(value: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    exists(subquery: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notExists(subquery: drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    between<T>(column: drizzleOrm.SQL.Aliased, min: T | drizzleOrm.SQLWrapper, max: T | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    between<TColumn extends drizzleOrm.AnyColumn>(column: TColumn, min: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper, max: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    between<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, min: unknown, max: unknown): drizzleOrm.SQL;
+    notBetween<T>(column: drizzleOrm.SQL.Aliased, min: T | drizzleOrm.SQLWrapper, max: T | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notBetween<TColumn extends drizzleOrm.AnyColumn>(column: TColumn, min: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper, max: drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notBetween<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, min: unknown, max: unknown): drizzleOrm.SQL;
+    like(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notLike(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    ilike(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    notIlike(column: drizzleOrm.Column | drizzleOrm.SQL.Aliased | drizzleOrm.SQL, value: string | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayContains<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayContains<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayContains<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayContained<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayContained<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayContained<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayOverlaps<T>(column: drizzleOrm.SQL.Aliased<T>, values: (T | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayOverlaps<TColumn extends drizzleOrm.Column>(column: TColumn, values: (drizzleOrm.GetColumnData<TColumn, "raw"> | drizzleOrm.Placeholder) | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    arrayOverlaps<T extends drizzleOrm.SQLWrapper>(column: Exclude<T, drizzleOrm.SQL.Aliased | drizzleOrm.Column>, values: (unknown | drizzleOrm.Placeholder)[] | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    eq: drizzleOrm.BinaryOperator;
+    ne: drizzleOrm.BinaryOperator;
+    gt: drizzleOrm.BinaryOperator;
+    gte: drizzleOrm.BinaryOperator;
+    lt: drizzleOrm.BinaryOperator;
+    lte: drizzleOrm.BinaryOperator;
+    asc(column: drizzleOrm.AnyColumn | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    desc(column: drizzleOrm.AnyColumn | drizzleOrm.SQLWrapper): drizzleOrm.SQL;
+    count(expression?: drizzleOrm.SQLWrapper): drizzleOrm.SQL<number>;
+    countDistinct(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<number>;
+    avg(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
+    avgDistinct(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
+    sum(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
+    sumDistinct(expression: drizzleOrm.SQLWrapper): drizzleOrm.SQL<string | null>;
+    max<T extends drizzleOrm.SQLWrapper>(expression: T): drizzleOrm.SQL<(T extends drizzleOrm.AnyColumn ? T["_"]["data"] : string) | null>;
+    min<T extends drizzleOrm.SQLWrapper>(expression: T): drizzleOrm.SQL<(T extends drizzleOrm.AnyColumn ? T["_"]["data"] : string) | null>;
+    l2Distance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
+    l1Distance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
+    innerProduct(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
+    cosineDistance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
+    hammingDistance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
+    jaccardDistance(column: drizzleOrm.SQLWrapper | drizzleOrm.AnyColumn, value: number[] | string[] | drizzle_orm_query_builders_query_builder.TypedQueryBuilder<any> | string): drizzleOrm.SQL;
+    isSQLWrapper(value: unknown): value is drizzleOrm.SQLWrapper;
+    name(value: string): drizzleOrm.Name;
+    isDriverValueEncoder(value: unknown): value is drizzleOrm.DriverValueEncoder<any, any>;
+    param<TData, TDriver>(value: TData, encoder?: drizzleOrm.DriverValueEncoder<TData, TDriver>): drizzleOrm.Param<TData, TDriver>;
+    sql: typeof drizzleOrm.sql;
+    placeholder<TName extends string>(name: TName): drizzleOrm.Placeholder<TName>;
+    fillPlaceholders(params: unknown[], values: Record<string, unknown>): unknown[];
+    isView(view: unknown): view is drizzleOrm.View;
+    getViewName<T extends drizzleOrm.View>(view: T): T["_"]["name"];
+    FakePrimitiveParam: typeof drizzleOrm.FakePrimitiveParam;
+    StringChunk: typeof drizzleOrm.StringChunk;
+    SQL: typeof drizzleOrm.SQL;
+    Name: typeof drizzleOrm.Name;
+    noopDecoder: drizzleOrm.DriverValueDecoder<any, any>;
+    noopEncoder: drizzleOrm.DriverValueEncoder<any, any>;
+    noopMapper: drizzleOrm.DriverValueMapper<any, any>;
+    Param: typeof drizzleOrm.Param;
+    Placeholder: typeof drizzleOrm.Placeholder;
+    View: typeof drizzleOrm.View;
+    Subquery: typeof drizzleOrm.Subquery;
+    WithSubquery: typeof drizzleOrm.WithSubquery;
+    isTable(table: unknown): table is drizzleOrm.Table;
+    getTableName<T extends drizzleOrm.Table>(table: T): T["_"]["name"];
+    getTableUniqueName<T extends drizzleOrm.Table>(table: T): `${T["_"]["schema"]}.${T["_"]["name"]}`;
+    Table: typeof drizzleOrm.Table;
+    haveSameKeys(left: Record<string, unknown>, right: Record<string, unknown>): boolean;
+    getTableColumns<T extends drizzleOrm.Table>(table: T): T["_"]["columns"];
+    getViewSelectedFields<T extends drizzleOrm.View>(view: T): T["_"]["selectedFields"];
+    isConfig(data: any): boolean;
+    ViewBaseConfig: typeof drizzleOrm.ViewBaseConfig;
+};
+
 declare const envSchema: _alepha_core.TObject<{
     POSTGRES_PROVIDER: _sinclair_typebox.TOptional<_sinclair_typebox.TUnsafe<"pg">>;
 }>;
@@ -1449,4 +1639,4 @@ declare class PostgresModule {
     protected getDefaultProviderName(): "pg";
 }
 
-export { $entity, $repository, $sequence, $table, $transaction, type BaseEntity, type BaseEntityKeys, type EntityDescriptorOptions, EntityNotFoundError, type ExtractManyRelations, type FilterOperators, type FromSchema, NodePostgresProvider, type NodePostgresProviderState, type NullToUndefined, type 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, type Page, type PageQuery, type PgAttrField, type PgDefault, type PgIdentityOptions, type PgMany, type PgManyOptions, type PgPrimaryKey, type PgQuery, type PgQueryWhere, type PgQueryWhereWithMany, type PgQueryWith, type PgQueryWithMap, type PgRef, type PgRefOptions, type PgSymbolKeys, type PgSymbols, type PgTableConfig, type PgTableWithColumnsAndSchema, PostgresModule, PostgresProvider, PostgresTypeProvider, type RemoveManyRelations, Repository, type RepositoryDescriptorOptions, RepositoryDescriptorProvider, type SQLLike, type SequenceDescriptor, type SequenceDescriptorOptions, type StatementOptions, type TEntity, type TPage, type TransactionContext, type TransactionDescriptorOptions, entityKeys, entitySchema, fromSchema, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToColumns, table, table2 };
+export { $entity, $repository, $sequence, $transaction, type BaseEntity, type BaseEntityKeys, type EntityDescriptorOptions, EntityNotFoundError, type ExtractManyRelations, type FilterOperators, type FromSchema, NodePostgresProvider, type NodePostgresProviderState, type NullToUndefined, type 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, type Page, type PageQuery, type PgAttrField, type PgDefault, type PgIdentityOptions, type PgMany, type PgManyOptions, type PgPrimaryKey, type PgQuery, type PgQueryWhere, type PgQueryWhereWithMany, type PgQueryWith, type PgQueryWithMap, type PgRef, type PgRefOptions, type PgSymbolKeys, type PgSymbols, type PgTableConfig, type PgTableWithColumnsAndSchema, PostgresModule, PostgresProvider, PostgresTypeProvider, type RemoveManyRelations, Repository, type RepositoryDescriptorOptions, RepositoryDescriptorProvider, type SQLLike, type SequenceDescriptor, type SequenceDescriptorOptions, type StatementOptions, type TEntity, type TPage, type TransactionContext, type TransactionDescriptorOptions, dzl, entityKeys, entitySchema, fromSchema, nullToUndefined, pageQuerySchema, pageSchema, pg, pgTableSchema, schema, schemaToColumns };

package/queue.d.ts

@@ -60,6 +60,7 @@ interface TSchema extends TKind, SchemaOptions {
 }
 
 declare class QueueProvider {
+    constructor();
     /**
      * Push a message to the queue.
      *

package/react/auth.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core from '@alepha/core';
-import { Alepha, KIND, OPTIONS } from '@alepha/core';
+import { Async, KIND, OPTIONS, Alepha } from '@alepha/core';
 import { UserAccountToken } from '@alepha/security';
 import * as _alepha_server from '@alepha/server';
 import { HttpClient } from '@alepha/server';
@@ -131,6 +131,28 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
+declare const KEY = "AUTH";
+type AccessToken = string;
+interface AuthDescriptorOptions {
+    name?: string;
+    oidc?: {
+        issuer: string;
+        clientId: string;
+        clientSecret?: string;
+        redirectUri?: string;
+    };
+    fallback?: () => Async<AccessToken>;
+}
+interface AuthDescriptor {
+    [KIND]: typeof KEY;
+    [OPTIONS]: AuthDescriptorOptions;
+    jwks: () => string;
+}
+declare const $auth: {
+    (options: AuthDescriptorOptions): AuthDescriptor;
+    [KIND]: string;
+};
+
 declare class ReactAuthProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
@@ -192,9 +214,6 @@ declare class ReactAuthProvider {
         name: any;
         email: any;
     } | undefined;
-    /**
-     *
-     */
     readonly logout: _alepha_server.RouteDescriptor<{
         query: TObject<{
             redirect: TOptional<TString>;
@@ -210,6 +229,7 @@ declare class ReactAuthProvider {
         client: Configuration;
         name: string;
         redirectUri: string;
+        fallback?: () => Async<AccessToken>;
     }>;
     /**
      *
@@ -232,6 +252,7 @@ interface AuthProvider {
     client: {
         get: () => Promise<Configuration>;
     };
+    fallback?: () => Async<AccessToken>;
 }
 interface ReactUser {
     id: string;
@@ -239,26 +260,6 @@ interface ReactUser {
     email?: string;
 }
 
-declare const KEY = "AUTH";
-interface AuthDescriptorOptions {
-    name?: string;
-    oidc?: {
-        issuer: string;
-        clientId: string;
-        clientSecret?: string;
-        redirectUri?: string;
-    };
-}
-interface AuthDescriptor {
-    [KIND]: typeof KEY;
-    [OPTIONS]: AuthDescriptorOptions;
-    jwks: () => string;
-}
-declare const $auth: {
-    (options: AuthDescriptorOptions): AuthDescriptor;
-    [KIND]: string;
-};
-
 declare const useAuth: () => AuthHook;
 interface AuthHook {
     user?: UserAccountToken;
@@ -273,12 +274,12 @@ declare class ReactAuth {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
     protected readonly client: HttpClient;
-    readonly slugs: {
+    static path: {
         login: string;
+        callback: string;
         logout: string;
     };
-    readonly start: _alepha_core.HookDescriptor<"client:onError">;
-    readonly onRender: _alepha_core.HookDescriptor<"react:browser:render">;
+    readonly onRender: _alepha_core.HookDescriptor<"react:transition:begin">;
     protected getUserFromCookies(): UserAccountToken | undefined;
     login(): void;
     logout(): void;
@@ -297,4 +298,4 @@ declare class ReactAuthModule {
     constructor();
 }
 
-export { $auth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthModule, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };
+export { $auth, type AccessToken, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthModule, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };