@getstrata/core 0.3.9 → 0.5.0

package/dist/bootstrap/httpKernel.d.ts

@@ -20,6 +20,8 @@ declare class HttpKernel {
     wrapAbility(ability: string, handler: RouteHandler): RouteHandler;
     wrapPolicy(resource: string, action: keyof Policy, handler: RouteHandler): RouteHandler;
     wrapLogin(handler: RouteHandler): RouteHandler;
+    wrapRegister(handler: RouteHandler): RouteHandler;
+    private wrapThrottle;
 }
 declare function createHttpKernel(dependencies: AppDependencies): HttpKernel;
 export type { MiddlewareGroupName };

package/dist/config/queue.d.ts

@@ -0,0 +1,8 @@
+interface QueueConfig {
+    driver: "sync" | "async" | "redis";
+    maxAttempts: number;
+    backoffMs: number;
+}
+declare const queueConfig: QueueConfig;
+export type { QueueConfig };
+export { queueConfig };

package/dist/config/rateLimit.d.ts

@@ -5,5 +5,6 @@ interface LoginRateLimitConfig {
 declare const LOCAL_LOGIN_RATE_LIMIT: LoginRateLimitConfig;
 declare const PRODUCTION_LOGIN_RATE_LIMIT: LoginRateLimitConfig;
 declare function resolveLoginRateLimit(): LoginRateLimitConfig;
+declare function resolveRegisterRateLimit(): LoginRateLimitConfig;
 export type { LoginRateLimitConfig };
-export { LOCAL_LOGIN_RATE_LIMIT, PRODUCTION_LOGIN_RATE_LIMIT, resolveLoginRateLimit };
+export { LOCAL_LOGIN_RATE_LIMIT, PRODUCTION_LOGIN_RATE_LIMIT, resolveLoginRateLimit, resolveRegisterRateLimit, };

package/dist/core/database/baseRepository.d.ts

@@ -1,8 +1,12 @@
-import { type PaginatedResult } from "../pagination/index.ts";
+import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
 import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
 import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
+import type { WhereNode } from "./whereBuilder.ts";
+type ExtendedQueryOptions<TEntity extends object> = QueryOptions<TEntity> & {
+    whereNodes?: WhereNode<TEntity>[];
+};
 interface DatabaseConnection {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
 }
@@ -11,11 +15,18 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     protected readonly table: TableDefinition<TEntity, PrimaryKey>;
     protected readonly connection: DatabaseConnection;
     constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
-    findAll(options?: QueryOptions<TEntity>): Promise<TEntity[]>;
+    findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
     paginate(options: {
         page: number;
         perPage: number;
-    } & Omit<QueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
+    } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<PaginatedResult<TEntity>>;
+    chunk(count: number, callback: (rows: TEntity[]) => Promise<boolean | void>, options?: Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<void>;
+    cursorPaginate(options: {
+        perPage: number;
+        cursor?: TEntity[PrimaryKey];
+        cursorColumn?: PrimaryKey;
+        direction?: "asc" | "desc";
+    } & Omit<ExtendedQueryOptions<TEntity>, "limit" | "offset">): Promise<CursorPaginatedResult<TEntity, TEntity[PrimaryKey]>>;
     findById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     findByIdOrThrow(id: TEntity[PrimaryKey], errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
     findByIds(ids: readonly TEntity[PrimaryKey][]): Promise<TEntity[]>;
@@ -29,9 +40,10 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     withConnection(connection: DatabaseConnection): this;
     getConnection(): DatabaseConnection;
+    getTable(): TableDefinition<TEntity, PrimaryKey>;
     query(where?: QueryWhere<TEntity>): RepositoryQuery<TEntity, PrimaryKey>;
     protected findWhere(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
-    protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): Promise<number>;
+    protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed" | "joins" | "groupBy">, whereNodes?: readonly WhereNode<TEntity>[]): Promise<number>;
     protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
     protected averageExpression(expression: string, alias: string, where?: QueryWhere<TEntity>): Promise<number>;
     protected pluckNumberValues(expression: string, alias: string, options?: QueryOptions<TEntity>): Promise<number[]>;

package/dist/core/database/boundConnection.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseConnection } from "./baseRepository";
+declare function bindDatabaseConnection(connection: DatabaseConnection): void;
+declare function getBoundDatabaseConnection(): DatabaseConnection | null;
+declare function resetBoundDatabaseConnection(): void;
+export { bindDatabaseConnection, getBoundDatabaseConnection, resetBoundDatabaseConnection };

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

@@ -2,11 +2,17 @@ export type { DatabaseConnection } from "./baseRepository.ts";
 export { default as BaseRepository } from "./baseRepository.ts";
 export { createDatabaseConnection } from "./connection.ts";
 export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
-export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, } from "./query.ts";
-export type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
-export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "./relationships.ts";
+export type { CastType, GlobalScopeFn, ModelConstructor } from "./model.ts";
+export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "./model.ts";
+export { buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, } from "./query.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "./relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "./relationships.ts";
 export { RepositoryQuery } from "./repositoryQuery.ts";
+export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "./schema/index.ts";
+export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "./schema/index.ts";
 export type { TableDefinition } from "./table.ts";
 export { defineTable } from "./table.ts";
 export { runInTransaction } from "./transaction.ts";
-export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryOperator, QueryOptions, QueryOrder, QueryWhere, UpdateValues, } from "./types.ts";
+export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, } from "./types.ts";
+export type { WhereNode } from "./whereBuilder.ts";
+export { WhereBuilder } from "./whereBuilder.ts";

package/dist/core/database/migrations/advisoryLock.d.ts

@@ -0,0 +1,6 @@
+declare const MIGRATION_LOCK_KEY = 42424242;
+type LockableDatabase = {
+    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
+};
+declare function withMigrationLock<T>(db: LockableDatabase, callback: () => Promise<T>, lockKey?: number): Promise<T>;
+export { MIGRATION_LOCK_KEY, withMigrationLock };

package/dist/core/database/migrations/runner.d.ts

@@ -1,4 +1,4 @@
-import type { Migration, MigrationDatabase, MigrationStatus } from "./types";
+import type { Migration, MigrationDatabase, MigrationStatus } from "./types.ts";
 type AppliedMigrationRow = {
     name: string;
     batch: number | string;
@@ -7,13 +7,19 @@ declare function ensureMigrationsTable(db: MigrationDatabase): Promise<void>;
 declare function getAppliedMigrations(db: MigrationDatabase): Promise<AppliedMigrationRow[]>;
 declare function loadMigrationsFromDirectory(directory: string): Promise<Migration[]>;
 declare function getMigrationStatus(db: MigrationDatabase, migrations: Migration[]): Promise<MigrationStatus[]>;
+declare function runPendingMigrations(db: MigrationDatabase, migrations: Migration[], options?: {
+    onMigration?: (name: string) => void;
+}): Promise<number>;
 declare function migrateDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    advisoryLock?: boolean;
     onMigration?: (name: string) => void;
 }): Promise<number>;
 declare function rollbackDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
     onMigration?: (name: string) => void;
 }): Promise<number>;
 declare function freshDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    advisoryLock?: boolean;
     onMigration?: (name: string) => void;
 }): Promise<void>;
-export { ensureMigrationsTable, freshDatabase, getAppliedMigrations, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, };
+export { withMigrationLock } from "./advisoryLock.ts";
+export { ensureMigrationsTable, freshDatabase, getAppliedMigrations, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, runPendingMigrations, };

package/dist/core/database/migrations/types.d.ts

@@ -1,5 +1,6 @@
 interface MigrationDatabase {
     unsafe<T = unknown>(query: string, params?: readonly unknown[]): Promise<T[]>;
+    schema?: import("../schema/schema.ts").SchemaBuilder;
 }
 interface Migration {
     name: string;

package/dist/core/database/model.d.ts

@@ -1,28 +1,57 @@
-import type BaseRepository from "./baseRepository";
-import type { BelongsToRelation, HasManyRelation } from "./relationships";
-import type { RepositoryQuery } from "./repositoryQuery";
-import type { QueryOptions, QueryWhere } from "./types";
-interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>> {
-    new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>): TModel;
+import type BaseRepository from "./baseRepository.ts";
+import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
+import type { RepositoryQuery } from "./repositoryQuery.ts";
+import type { QueryOptions, QueryWhere } from "./types.ts";
+type CastType = "date" | "datetime" | "json" | "bool" | "boolean";
+type LoadedAttributes = Record<string, unknown>;
+type ModelCasts = Partial<Record<string, CastType>>;
+type GlobalScopeFn<TEntity extends object, PrimaryKey extends keyof TEntity & string> = (query: RepositoryQuery<TEntity, PrimaryKey>) => RepositoryQuery<TEntity, PrimaryKey>;
+type ModelClassType<TEntity extends object, PrimaryKey extends keyof TEntity & string> = typeof Model & (new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean) => Model<TEntity, PrimaryKey>);
+interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>> extends ModelClassType<TEntity, PrimaryKey> {
+    new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): TModel;
 }
+declare function hydrateValue(value: unknown, cast: CastType): unknown;
+declare function dehydrateValue(value: unknown, cast: CastType): unknown;
+declare function filterMassAssignable(fillable: readonly string[] | undefined, guarded: readonly string[] | true | undefined, input: LoadedAttributes): LoadedAttributes;
+declare function applyCasts(values: LoadedAttributes, casts: ModelCasts, direction: "hydrate" | "dehydrate"): LoadedAttributes;
 declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
-    protected readonly attributes: TEntity;
+    protected attributes: TEntity;
     protected readonly repository: BaseRepository<TEntity, PrimaryKey>;
-    constructor(attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>);
+    static $fillable?: readonly string[];
+    static $guarded?: readonly string[] | true;
+    static $casts: ModelCasts;
+    static $timestamps: boolean;
+    private _exists;
+    constructor(attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean);
+    get $exists(): boolean;
     get<K extends keyof TEntity>(key: K): TEntity[K];
     get id(): TEntity[PrimaryKey];
     toObject(): TEntity;
     protected primaryKey(): PrimaryKey;
-    static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>): BaseRepository<TEntity, PrimaryKey>;
-    static query<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>): RepositoryQuery<TEntity, PrimaryKey>;
-    static find<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, id: TEntity[PrimaryKey]): Promise<TModel | null>;
-    static findOrFail<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, id: TEntity[PrimaryKey], errorFactory?: (id: TEntity[PrimaryKey]) => Error): Promise<TModel>;
-    static all<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, options?: QueryOptions<TEntity>): Promise<TModel[]>;
-    static firstWhere<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TModel | null>;
+    protected static primaryKeyField(this: typeof Model): string;
+    protected static hydrateAttributes<TEntity extends object>(this: typeof Model, attributes: TEntity): TEntity;
+    protected static dehydrateAttributes(this: typeof Model, attributes: LoadedAttributes): LoadedAttributes;
+    protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: typeof Model, record: TEntity, repository: BaseRepository<TEntity, PrimaryKey>, exists?: boolean): Model<TEntity, PrimaryKey>;
+    static boot(): void;
+    static addGlobalScope<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, _name: string, scope: GlobalScopeFn<TEntity, PrimaryKey>): void;
+    static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): BaseRepository<TEntity, PrimaryKey>;
+    static query<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object): RepositoryQuery<TEntity, PrimaryKey>;
+    static create(this: object, attributes: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
+    static find(this: object, id: unknown): Promise<Model<Record<string, unknown>, "id"> | null>;
+    static findOrFail(this: object, id: unknown, errorFactory?: (id: unknown) => Error): Promise<Model<Record<string, unknown>, "id">>;
+    static all(this: object, options?: Omit<QueryOptions<object>, "where">): Promise<Array<Model<Record<string, unknown>, "id">>>;
+    static firstWhere(this: object, where: QueryWhere<object>, options?: Omit<QueryOptions<object>, "where">): Promise<Model<Record<string, unknown>, "id"> | null>;
+    save(): Promise<this>;
+    update(changes: Partial<TEntity>): Promise<this>;
+    delete(): Promise<boolean>;
+    forceDelete(): Promise<boolean>;
+    restore(): Promise<this | null>;
     loadHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild[]>>;
+    loadHasOne<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasOneRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): Promise<this & Record<Alias, TChild | undefined>>;
     loadBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<this & Record<Alias, TParent | undefined>>;
+    loadBelongsToMany<TRelated extends object, Pivot extends object, ParentKey extends keyof TEntity & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string, Alias extends string>(as: Alias, relation: BelongsToManyRelation<TEntity, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>, relatedRepository: BaseRepository<TRelated, RelatedKey>, options?: Omit<QueryOptions<TRelated>, "where">): Promise<this & Record<Alias, TRelated[]>>;
     mergeAttributes(patch: Partial<TEntity>): this;
 }
-declare function registerModelRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(model: ModelConstructor<TEntity, PrimaryKey, TModel>, repository: BaseRepository<TEntity, PrimaryKey>): ModelConstructor<TEntity, PrimaryKey, TModel> & typeof Model;
-export type { ModelConstructor };
-export { Model, registerModelRepository };
+declare function registerModelRepository<TModelClass>(model: TModelClass, repository: object): TModelClass;
+export type { CastType, GlobalScopeFn, ModelClassType, ModelConstructor };
+export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, };

package/dist/core/database/query.d.ts

@@ -1,51 +1,63 @@
 import type { TableDefinition } from "./table.ts";
-import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
+import type { MutationValues, QueryJoin, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
+import type { WhereNode } from "./whereBuilder.ts";
 declare function quoteIdentifier(identifier: string): string;
 declare function qualifyColumn(tableName: string, column: string): string;
-declare function buildWhereClause<TEntity>(tableName: string, where?: QueryWhere<TEntity>): {
+declare function resolveQualifiedColumn(defaultTable: string, columnName: string): string;
+declare function parseQualifiedColumn(reference: string): {
+    table: string;
+    column: string;
+};
+declare function buildWhereClause<TEntity extends object>(tableName: string, where?: QueryWhere<TEntity>): {
+    clause: string;
+    params: unknown[];
+};
+declare function buildAdvancedWhereClause<TEntity extends object>(tableName: string, where?: QueryWhere<TEntity>, whereNodes?: readonly WhereNode<TEntity>[]): {
     clause: string;
     params: unknown[];
 };
 declare function resolveSoftDeleteColumn<TEntity>(table: TableDefinition<TEntity>): string | null;
-declare function buildQueryWhereClause<TEntity>(table: TableDefinition<TEntity>, options?: Pick<QueryOptions<TEntity>, "where" | "withTrashed" | "onlyTrashed">): {
+declare function buildQueryWhereClause<TEntity extends object>(table: TableDefinition<TEntity>, options?: Pick<QueryOptions<TEntity>, "where" | "withTrashed" | "onlyTrashed">, whereNodes?: readonly WhereNode<TEntity>[]): {
     clause: string;
     params: unknown[];
 };
-declare function buildOrderByClause<TEntity>(tableName: string, orderBy?: QueryOptions<TEntity>["orderBy"]): string;
-declare function buildSelectQuery<TEntity>(table: TableDefinition<TEntity>, options?: QueryOptions<TEntity>): {
+declare function buildOrderByClause<TEntity extends object>(tableName: string, orderBy?: QueryOptions<TEntity>["orderBy"]): string;
+declare function buildJoinClause(joins?: readonly QueryJoin[]): string;
+declare function buildSelectQuery<TEntity extends object>(table: TableDefinition<TEntity>, options?: QueryOptions<TEntity>, whereNodes?: readonly WhereNode<TEntity>[]): {
     text: string;
     params: unknown[];
 };
-declare function buildCountQuery<TEntity>(table: TableDefinition<TEntity>, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): {
+declare function buildCountQuery<TEntity extends object>(table: TableDefinition<TEntity>, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed" | "joins" | "groupBy">, whereNodes?: readonly WhereNode<TEntity>[]): {
     text: string;
     params: unknown[];
 };
-declare function buildProjectionQuery<TEntity>(table: TableDefinition<TEntity>, expression: string, alias: string, options?: QueryOptions<TEntity>): {
+declare function buildProjectionQuery<TEntity extends object>(table: TableDefinition<TEntity>, expression: string, alias: string, options?: QueryOptions<TEntity>, whereNodes?: readonly WhereNode<TEntity>[]): {
     text: string;
     params: unknown[];
 };
-declare function buildGroupedCountQuery<TEntity, K extends keyof TEntity & string>(table: TableDefinition<TEntity>, column: K, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): {
+declare function assertSafeProjectionExpression(expression: string): void;
+declare function buildGroupedCountQuery<TEntity extends object, K extends keyof TEntity & string>(table: TableDefinition<TEntity>, column: K, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): {
     text: string;
     params: unknown[];
 };
-declare function buildInsertQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, values: MutationValues<TEntity>): {
+declare function buildInsertQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, values: MutationValues<TEntity>): {
     text: string;
     params: unknown[];
 };
-declare function buildUpdateQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): {
+declare function buildUpdateQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): {
     text: string;
     params: unknown[];
 };
-declare function buildSoftDeleteByIdQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], deletedAt: Date): {
+declare function buildSoftDeleteByIdQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], deletedAt: Date): {
     text: string;
     params: unknown[];
 };
-declare function buildRestoreByIdQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
+declare function buildRestoreByIdQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
     text: string;
     params: unknown[];
 };
-declare function buildDeleteByIdQuery<TEntity, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
+declare function buildDeleteByIdQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
     text: string;
     params: unknown[];
 };
-export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, };
+export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };

package/dist/core/database/relationships.d.ts

@@ -4,23 +4,53 @@ interface HasManyRelation<TParent, TChild, LocalKey extends keyof TParent & stri
     localKey: LocalKey;
     foreignKey: ForeignKey;
 }
+interface HasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string> {
+    type: "hasOne";
+    name: string;
+    localKey: LocalKey;
+    foreignKey: ForeignKey;
+}
 interface BelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string = keyof TChild & string, OwnerKey extends keyof TParent & string = keyof TParent & string> {
     type: "belongsTo";
     name: string;
     foreignKey: ForeignKey;
     ownerKey: OwnerKey;
 }
+interface BelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string = keyof TParent & string, RelatedKey extends keyof TRelated & string = keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string = keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string = keyof Pivot & string> {
+    type: "belongsToMany";
+    name: string;
+    pivotTable: string;
+    parentKey: ParentKey;
+    relatedKey: RelatedKey;
+    foreignPivotKey: ForeignPivotKey;
+    relatedPivotKey: RelatedPivotKey;
+}
 declare function hasMany<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string>(definition: {
     name: string;
     localKey: LocalKey;
     foreignKey: ForeignKey;
 }): HasManyRelation<TParent, TChild, LocalKey, ForeignKey>;
+declare function hasOne<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    localKey: LocalKey;
+    foreignKey: ForeignKey;
+}): HasOneRelation<TParent, TChild, LocalKey, ForeignKey>;
 declare function belongsTo<TChild, TParent, ForeignKey extends keyof TChild & string = keyof TChild & string, OwnerKey extends keyof TParent & string = keyof TParent & string>(definition: {
     name: string;
     foreignKey: ForeignKey;
     ownerKey: OwnerKey;
 }): BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>;
+declare function belongsToMany<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string = keyof TParent & string, RelatedKey extends keyof TRelated & string = keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string = keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string = keyof Pivot & string>(definition: {
+    name: string;
+    pivotTable: string;
+    parentKey: ParentKey;
+    relatedKey: RelatedKey;
+    foreignPivotKey: ForeignPivotKey;
+    relatedPivotKey: RelatedPivotKey;
+}): BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>;
 declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasManyRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild[]>;
+declare function indexHasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasOneRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild | undefined>;
 declare function indexBelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parents: readonly TParent[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>): Map<TChild[ForeignKey], TParent>;
-export type { BelongsToRelation, HasManyRelation };
-export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation };
+declare function indexBelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string>(parents: readonly TParent[], pivotRows: readonly Pivot[], relatedRows: readonly TRelated[], relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>): Map<TParent[ParentKey], TRelated[]>;
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation };
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, };

package/dist/core/database/repositoryConnection.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseConnection } from "./baseRepository";
+declare function resolveRepositoryConnection(): DatabaseConnection;
+declare const repositoryConnection: DatabaseConnection;
+export { repositoryConnection, resolveRepositoryConnection };

package/dist/core/database/repositoryQuery.d.ts

@@ -1,20 +1,35 @@
+import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
 import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
+import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
 declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
     private readonly repository;
     private whereClause;
     private queryOptions;
     private readonly eagerLoads;
+    private readonly whereNodes;
     constructor(repository: BaseRepository<TEntity, PrimaryKey>, whereClause?: QueryWhere<TEntity>, queryOptions?: Omit<QueryOptions<TEntity>, "where">);
-    where(where: QueryWhere<TEntity>): this;
+    where(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
+    orWhere(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
     orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
     limit(limit: number): this;
+    offset(offset: number): this;
+    join(left: `${string}.${string}`, right: `${string}.${string}`): this;
+    leftJoin(left: `${string}.${string}`, right: `${string}.${string}`): this;
+    groupBy(groupBy: QueryOptions<TEntity>["groupBy"]): this;
+    having(having: QueryWhere<TEntity>): this;
     withHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
     withBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): this;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
+    paginate(options: {
+        page: number;
+        perPage: number;
+    }): Promise<PaginatedResult<TEntity>>;
+    private buildOptions;
+    private addJoin;
     private attach;
 }
 export { RepositoryQuery };

package/dist/core/database/schema/blueprint.d.ts

@@ -0,0 +1,47 @@
+import { ColumnDefinition, ForeignIdColumnDefinition } from "./columnDefinition.ts";
+type IndexKind = "index" | "unique" | "partial" | "uniquePartial" | "fullText" | "gin";
+interface IndexDefinition {
+    name?: string;
+    columns: string[];
+    kind: IndexKind;
+    where?: string;
+    order?: "asc" | "desc";
+}
+type BlueprintAction = "create" | "alter" | "drop";
+declare class Blueprint {
+    readonly table: string;
+    readonly action: BlueprintAction;
+    readonly columns: ColumnDefinition[];
+    readonly indexes: IndexDefinition[];
+    readonly droppedColumns: string[];
+    readonly droppedIndexes: string[];
+    constructor(table: string, action: BlueprintAction);
+    id(name?: string): ColumnDefinition;
+    string(name: string, length?: number): ColumnDefinition;
+    text(name: string): ColumnDefinition;
+    boolean(name: string): ColumnDefinition;
+    integer(name: string): ColumnDefinition;
+    bigInteger(name: string): ColumnDefinition;
+    timestamp(name: string): ColumnDefinition;
+    json(name: string): ColumnDefinition;
+    jsonb(name: string): ColumnDefinition;
+    foreignId(name: string): ForeignIdColumnDefinition;
+    timestamps(): void;
+    softDeletes(): void;
+    dropColumn(name: string): void;
+    dropSoftDeletes(): void;
+    dropIndex(name: string): void;
+    unique(columns: string | string[], name?: string): void;
+    index(columns: string | string[], options?: {
+        name?: string;
+        order?: "asc" | "desc";
+    }): void;
+    partialIndex(columns: string | string[], where: string, nameOrOptions?: string | {
+        name?: string;
+        unique?: boolean;
+    }): void;
+    fullText(columns: string | string[], name?: string): void;
+    ginIndex(column: string, name?: string): void;
+}
+export type { BlueprintAction, IndexDefinition, IndexKind };
+export { Blueprint };

package/dist/core/database/schema/columnDefinition.d.ts

@@ -0,0 +1,36 @@
+type ColumnKind = "id" | "string" | "text" | "boolean" | "integer" | "bigInteger" | "timestamp" | "json" | "jsonb" | "foreignId";
+interface ForeignKeyOptions {
+    referencesTable: string;
+    referencesColumn: string;
+    onDelete?: "cascade" | "set null" | "restrict";
+}
+declare class ColumnDefinition {
+    readonly name: string;
+    kind: ColumnKind;
+    length?: number;
+    isNullable: boolean;
+    isPrimary: boolean;
+    isUnique: boolean;
+    autoIncrement: boolean;
+    defaultValue?: string;
+    checkExpression?: string;
+    foreignKey?: ForeignKeyOptions;
+    constructor(name: string, kind: ColumnKind);
+    nullable(): this;
+    notNullable(): this;
+    default(value: string | number | boolean): this;
+    defaultRaw(expression: string): this;
+    unique(): this;
+    primary(): this;
+    check(expression: string): this;
+}
+declare class ForeignIdColumnDefinition extends ColumnDefinition {
+    constructor(name: string);
+    references(table: string, column?: string): this;
+    constrained(table?: string): this;
+    cascadeOnDelete(): this;
+    nullOnDelete(): this;
+}
+declare function inferReferencedTable(columnName: string): string;
+export type { ColumnKind, ForeignKeyOptions };
+export { ColumnDefinition, ForeignIdColumnDefinition, inferReferencedTable };

package/dist/core/database/schema/driver.d.ts

@@ -0,0 +1,8 @@
+type DatabaseDriver = "pgsql" | "mysql" | "sqlite";
+interface ResolveDatabaseDriverOptions {
+    url?: string;
+    connection?: string;
+}
+declare function resolveDatabaseDriver(options?: ResolveDatabaseDriverOptions): DatabaseDriver;
+export type { DatabaseDriver, ResolveDatabaseDriverOptions };
+export { resolveDatabaseDriver };

package/dist/core/database/schema/errors.d.ts

@@ -0,0 +1,4 @@
+declare class UnsupportedSchemaFeatureError extends Error {
+    constructor(feature: string, driver: string);
+}
+export { UnsupportedSchemaFeatureError };

package/dist/core/database/schema/grammars/compileStatements.d.ts

@@ -0,0 +1,8 @@
+import type { Blueprint, IndexDefinition } from "../blueprint.ts";
+import type { ColumnDefinition } from "../columnDefinition.ts";
+import type { DatabaseDriver } from "../driver.ts";
+declare function compileDropTable(driver: DatabaseDriver, tableName: string): string[];
+declare function compileColumn(driver: DatabaseDriver, column: ColumnDefinition, mode: "create" | "alter"): string;
+declare function compileIndex(_driver: DatabaseDriver, tableName: string, index: IndexDefinition): string;
+declare function compileBlueprint(driver: DatabaseDriver, blueprint: Blueprint): string[];
+export { compileBlueprint, compileColumn, compileDropTable, compileIndex };

package/dist/core/database/schema/grammars/createGrammar.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseDriver } from "../driver.ts";
+import type { Grammar } from "./grammar.ts";
+declare function createGrammar(driver: DatabaseDriver): Grammar;
+export { createGrammar };

package/dist/core/database/schema/grammars/grammar.d.ts

@@ -0,0 +1,10 @@
+import type { Blueprint } from "../blueprint.ts";
+import type { ColumnDefinition } from "../columnDefinition.ts";
+import type { DatabaseDriver } from "../driver.ts";
+interface Grammar {
+    readonly driver: DatabaseDriver;
+    compile(blueprint: Blueprint): string[];
+}
+declare function compileColumnType(driver: DatabaseDriver, column: ColumnDefinition): string;
+export type { Grammar };
+export { compileColumnType };

package/dist/core/database/schema/grammars/index.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseDriver } from "../driver.ts";
+import type { Grammar } from "./grammar.ts";
+import { MySqlGrammar } from "./mysqlGrammar.ts";
+import { PostgresGrammar } from "./postgresGrammar.ts";
+import { SqliteGrammar } from "./sqliteGrammar.ts";
+declare function grammarForDriver(driver: DatabaseDriver): Grammar;
+export { grammarForDriver, MySqlGrammar, PostgresGrammar, SqliteGrammar };

package/dist/core/database/schema/grammars/mysqlGrammar.d.ts

@@ -0,0 +1,2 @@
+declare const MySqlGrammar: import("./grammar.ts").Grammar;
+export { MySqlGrammar };

package/dist/core/database/schema/grammars/postgresGrammar.d.ts

@@ -0,0 +1,2 @@
+declare const PostgresGrammar: import("./grammar.ts").Grammar;
+export { PostgresGrammar };

package/dist/core/database/schema/grammars/sqliteGrammar.d.ts

@@ -0,0 +1,2 @@
+declare const SqliteGrammar: import("./grammar.ts").Grammar;
+export { SqliteGrammar };

package/dist/core/database/schema/index.d.ts

@@ -0,0 +1,12 @@
+export type { BlueprintAction, IndexDefinition, IndexKind } from "./blueprint.ts";
+export { Blueprint } from "./blueprint.ts";
+export type { ColumnKind, ForeignKeyOptions } from "./columnDefinition.ts";
+export { ColumnDefinition, ForeignIdColumnDefinition, inferReferencedTable, } from "./columnDefinition.ts";
+export type { DatabaseDriver, ResolveDatabaseDriverOptions } from "./driver.ts";
+export { resolveDatabaseDriver } from "./driver.ts";
+export { UnsupportedSchemaFeatureError } from "./errors.ts";
+export { compileBlueprint } from "./grammars/compileStatements.ts";
+export type { Grammar } from "./grammars/grammar.ts";
+export { grammarForDriver, MySqlGrammar, PostgresGrammar, SqliteGrammar, } from "./grammars/index.ts";
+export type { BlueprintCallback } from "./schema.ts";
+export { createSchemaBuilder, Schema, SchemaBuilder } from "./schema.ts";

package/dist/core/database/schema/schema.d.ts

@@ -0,0 +1,21 @@
+import type { MigrationDatabase } from "../migrations/types.ts";
+import { Blueprint } from "./blueprint.ts";
+import type { DatabaseDriver } from "./driver.ts";
+import { resolveDatabaseDriver } from "./driver.ts";
+type BlueprintCallback = (table: Blueprint) => void;
+declare class SchemaBuilder {
+    #private;
+    constructor(driver: DatabaseDriver);
+    create(table: string, callback: BlueprintCallback): this;
+    table(table: string, callback: BlueprintCallback): this;
+    drop(table: string): this;
+    toSql(): string[];
+    execute(db: MigrationDatabase): Promise<void>;
+}
+declare class Schema {
+    static builder(driver?: DatabaseDriver): SchemaBuilder;
+    static run(db: MigrationDatabase, driver: DatabaseDriver, callback: (schema: SchemaBuilder) => void | Promise<void>): Promise<void>;
+}
+declare function createSchemaBuilder(db: MigrationDatabase, driver?: DatabaseDriver): SchemaBuilder;
+export type { BlueprintCallback };
+export { createSchemaBuilder, resolveDatabaseDriver, Schema, SchemaBuilder };

package/dist/core/database/seeders/runner.d.ts

@@ -0,0 +1,6 @@
+import type { Seeder, SeederDatabase } from "./types.ts";
+declare function loadSeedersFromDirectory(directory: string): Promise<Seeder[]>;
+declare function runSeedersFromDirectory(directory: string, db: SeederDatabase, options?: {
+    onSeeder?: (name: string) => void;
+}): Promise<number>;
+export { loadSeedersFromDirectory, runSeedersFromDirectory };