@getstrata/bootstrap 0.2.22 → 0.2.23

package/dist/core/config/envSchema.d.ts

@@ -1,12 +0,0 @@
-interface EnvRule {
-    required?: boolean;
-    integer?: boolean;
-    minimum?: number;
-    default?: string;
-    pattern?: RegExp;
-}
-type EnvSchema = Record<string, EnvRule>;
-declare function defineEnvSchema(schema: EnvSchema): EnvSchema;
-declare function validateEnv(schema: EnvSchema, env?: Record<string, string | undefined>): Record<string, string>;
-export type { EnvRule, EnvSchema };
-export { defineEnvSchema, validateEnv };

package/dist/core/contracts/container.d.ts

@@ -1,30 +0,0 @@
-type ServiceFactory<T> = (container: ServiceContainer) => T;
-interface ServiceContainerLike {
-    has(key: string): boolean;
-    resolve<T>(key: string): T;
-}
-declare class ServiceContainer implements ServiceContainerLike {
-    private readonly services;
-    private readonly singletonFactories;
-    private readonly bindings;
-    set<T>(key: string, value: T): T;
-    singleton<T>(key: string, factory: ServiceFactory<T>): void;
-    bind<T>(key: string, factory: ServiceFactory<T>): void;
-    get<T>(key: string): T;
-    resolve<T>(key: string): T;
-    has(key: string): boolean;
-}
-interface ConfigStoreLike {
-    get<T>(key: string): T | undefined;
-    require<T>(key: string): T;
-    has(key: string): boolean;
-}
-declare class ConfigStore implements ConfigStoreLike {
-    private readonly values;
-    set<T>(key: string, value: T): T;
-    get<T>(key: string): T | undefined;
-    require<T>(key: string): T;
-    has(key: string): boolean;
-}
-export type { ConfigStoreLike, ServiceContainerLike, ServiceFactory };
-export { ConfigStore, ServiceContainer };

package/dist/core/contracts/di.d.ts

@@ -1,31 +0,0 @@
-import type { CacheLike } from "../../types/services";
-import type { StorageManager } from "../storage/storage";
-import type { ConfigStore, ConfigStoreLike, ServiceContainer, ServiceFactory } from "./container";
-type AppRouteMap = Record<string, any>;
-type CachedJson = <T>(cacheKey: string, loader: () => Promise<T>, tags?: string[], request?: Request) => Promise<Response>;
-interface AppDependencies {
-    container: ServiceContainer;
-    cache: CacheLike;
-    storage: StorageManager;
-}
-type MutableAppDependencies = Partial<Omit<AppDependencies, "container">> & Pick<AppDependencies, "container">;
-interface ProviderContext {
-    container: ServiceContainer;
-    config: ConfigStore;
-    dependencies: MutableAppDependencies;
-}
-interface ServiceProvider {
-    name: string;
-    register?(context: ProviderContext): void;
-    boot?(context: ProviderContext): void;
-}
-interface AppContext {
-    container: ServiceContainer;
-    config: ConfigStoreLike;
-    dependencies: AppDependencies;
-}
-declare function getRequiredDependency<K extends keyof AppDependencies>(dependencies: Partial<AppDependencies>, key: K): AppDependencies[K];
-declare function assertAppDependenciesComplete(dependencies: MutableAppDependencies): asserts dependencies is AppDependencies;
-declare function resolveService<T>(dependencies: AppDependencies, token: string): T;
-export type { AppContext, AppDependencies, AppRouteMap, CachedJson, MutableAppDependencies, ProviderContext, ServiceFactory, ServiceProvider, };
-export { assertAppDependenciesComplete, getRequiredDependency, resolveService };

package/dist/core/contracts/serviceContainer.d.ts

@@ -1 +0,0 @@
-export type { ServiceContainerLike } from "./container.ts";

package/dist/core/contracts/serviceTokens.d.ts

@@ -1,8 +0,0 @@
-declare const CORE_CONFIG_TOKEN = "core.config";
-declare const CORE_CACHE_TOKEN = "core.cache";
-declare const CORE_QUEUE_TOKEN = "core.queue";
-declare const CORE_EVENT_BUS_TOKEN = "core.eventBus";
-declare const CORE_POLICY_GATE_TOKEN = "core.policyGate";
-declare const CORE_AUTH_TOKEN = "core.auth";
-declare const CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
-export { CORE_AUTH_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_EVENT_BUS_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TOKEN_SERVICE_TOKEN, };

package/dist/core/crypto/fieldEncryption.d.ts

@@ -1,13 +0,0 @@
-declare function resolveEncryptionKey(): Buffer | null;
-declare function isFieldEncryptionEnabled(): boolean;
-declare function encryptField(plaintext: string, key: Buffer): string;
-declare function decryptField(value: string, key: Buffer): string;
-declare function hashLookupValue(normalizedValue: string, key: Buffer): string;
-declare function normalizeEmail(email: string): string;
-declare function protectEmail(email: string): {
-    storedEmail: string;
-    emailLookup: string;
-};
-declare function revealEmail(storedEmail: string): string;
-declare function emailLookupForQuery(email: string): string;
-export { decryptField, emailLookupForQuery, encryptField, hashLookupValue, isFieldEncryptionEnabled, normalizeEmail, protectEmail, resolveEncryptionKey, revealEmail, };

package/dist/core/crypto/mfaSecret.d.ts

@@ -1,3 +0,0 @@
-declare function protectMfaSecret(secret: string): string;
-declare function revealMfaSecret(stored: string | null | undefined): string | null;
-export { protectMfaSecret, revealMfaSecret };

package/dist/core/crypto/nonCryptographicHash.d.ts

@@ -1,2 +0,0 @@
-declare function nonCryptographicDigest(input: string): string;
-export { nonCryptographicDigest };

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

@@ -1,67 +0,0 @@
-import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
-import { type BelongsToRelation, type HasManyRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } 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[]>;
-    begin?<T>(callback: (transaction: DatabaseConnection) => Promise<T>): Promise<T>;
-    close?(): Promise<void>;
-}
-interface SqlDatabaseConnection extends DatabaseConnection {
-    (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
-}
-type ErrorFactory<TValue> = (value: TValue) => Error;
-declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
-    protected readonly table: TableDefinition<TEntity, PrimaryKey>;
-    protected readonly connection: DatabaseConnection;
-    constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
-    findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
-    paginate(options: {
-        page: number;
-        perPage: number;
-    } & 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[]>;
-    firstOrNull(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where" | "limit">): Promise<TEntity | null>;
-    create(values: MutationValues<TEntity>): Promise<TEntity>;
-    updateById(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
-    updateByIdOrThrow(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>, errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
-    deleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
-    softDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
-    forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
-    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" | "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[]>;
-    protected countGroupedBy<K extends keyof TEntity & string>(column: K, where?: QueryWhere<TEntity>): Promise<Array<{
-        value: TEntity[K] | null;
-        count: number;
-    }>>;
-    findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
-    loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
-    loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
-    loadMorphManyForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphManyRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
-    loadMorphOneForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphOneRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity | undefined>>;
-    loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
-}
-export default BaseRepository;
-export type { DatabaseConnection, SqlDatabaseConnection };

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

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

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

@@ -1,5 +0,0 @@
-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/connection.d.ts

@@ -1,7 +0,0 @@
-import type { DatabaseConnection } from "./baseRepository.ts";
-type UnsafeQueryable = {
-    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
-};
-declare function createDatabaseConnection(source: UnsafeQueryable): DatabaseConnection;
-export type { UnsafeQueryable };
-export { createDatabaseConnection };

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

@@ -1,8 +0,0 @@
-type ActiveDatabaseHandle = {
-    unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
-};
-declare function runWithDatabaseConnection<T>(connection: ActiveDatabaseHandle, callback: () => T | Promise<T>): T | Promise<T>;
-declare function getActiveDatabaseConnection<T extends ActiveDatabaseHandle>(fallback: T): T;
-declare function hasActiveDatabaseConnection(): boolean;
-export type { ActiveDatabaseHandle };
-export { getActiveDatabaseConnection, hasActiveDatabaseConnection, runWithDatabaseConnection };

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

@@ -1,6 +0,0 @@
-import type { SqlDatabaseConnection } from "./baseRepository";
-declare function registerDefaultDatabasePool(connection: SqlDatabaseConnection): void;
-declare function getDefaultDatabasePool(): SqlDatabaseConnection;
-declare function getDefaultDatabaseQuery(): SqlDatabaseConnection;
-declare function resetDefaultDatabasePoolForTests(): void;
-export { getDefaultDatabasePool, getDefaultDatabaseQuery, registerDefaultDatabasePool, resetDefaultDatabasePoolForTests, };

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

@@ -1,12 +0,0 @@
-import { HttpError } from "../errors/http";
-interface PostgresErrorLike {
-    code?: string;
-    errno?: string | number;
-    constraint?: string;
-    detail?: string;
-    message?: string;
-}
-declare function isPostgresError(error: unknown): error is PostgresErrorLike;
-declare function mapDatabaseError(error: unknown): HttpError;
-declare function withDatabaseErrorHandling<TValue>(operation: () => Promise<TValue>): Promise<TValue>;
-export { isPostgresError, mapDatabaseError, withDatabaseErrorHandling };

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

@@ -1,18 +0,0 @@
-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 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, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "./relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } 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, 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

@@ -1,6 +0,0 @@
-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,25 +0,0 @@
-import type { Migration, MigrationDatabase, MigrationStatus } from "./types.ts";
-type AppliedMigrationRow = {
-    name: string;
-    batch: number | string;
-};
-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 { withMigrationLock } from "./advisoryLock.ts";
-export { ensureMigrationsTable, freshDatabase, getAppliedMigrations, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, runPendingMigrations, };

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

@@ -1,15 +0,0 @@
-interface MigrationDatabase {
-    unsafe<T = unknown>(query: string, params?: readonly unknown[]): Promise<T[]>;
-    schema?: import("../schema/schema.ts").SchemaBuilder;
-}
-interface Migration {
-    name: string;
-    up(db: MigrationDatabase): Promise<void>;
-    down(db: MigrationDatabase): Promise<void>;
-}
-type MigrationStatus = {
-    name: string;
-    status: "up" | "pending";
-    batch: number | null;
-};
-export type { Migration, MigrationDatabase, MigrationStatus };

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

@@ -1,57 +0,0 @@
-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 attributes: TEntity;
-    protected readonly 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;
-    protected static primaryKeyField(this: object): string;
-    protected static hydrateAttributes<TEntity extends object>(this: object, attributes: TEntity): TEntity;
-    protected static dehydrateAttributes(this: object, attributes: LoadedAttributes): LoadedAttributes;
-    protected static fromRecord<TEntity extends object, PrimaryKey extends keyof TEntity & string>(this: object, 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<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,63 +0,0 @@
-import type { TableDefinition } from "./table.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 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>[], params?: unknown[]): {
-    clause: string;
-    params: unknown[];
-};
-declare function resolveSoftDeleteColumn<TEntity>(table: TableDefinition<TEntity>): string | null;
-declare function buildQueryWhereClause<TEntity extends object>(table: TableDefinition<TEntity>, options?: Pick<QueryOptions<TEntity>, "where" | "withTrashed" | "onlyTrashed">, whereNodes?: readonly WhereNode<TEntity>[], params?: unknown[]): {
-    clause: string;
-    params: unknown[];
-};
-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 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 extends object>(table: TableDefinition<TEntity>, expression: string, alias: string, options?: QueryOptions<TEntity>, whereNodes?: readonly WhereNode<TEntity>[]): {
-    text: string;
-    params: unknown[];
-};
-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 extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, values: MutationValues<TEntity>): {
-    text: string;
-    params: unknown[];
-};
-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 extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey], deletedAt: Date): {
-    text: string;
-    params: unknown[];
-};
-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 extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, id: TEntity[PrimaryKey]): {
-    text: string;
-    params: unknown[];
-};
-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/queryProxy.d.ts

@@ -1,3 +0,0 @@
-import type { SqlDatabaseConnection } from "./baseRepository";
-declare function createDatabaseQueryProxy(pool: SqlDatabaseConnection): SqlDatabaseConnection;
-export { createDatabaseQueryProxy };

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

@@ -1,100 +0,0 @@
-interface HasManyRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, ForeignKey extends keyof TChild & string = keyof TChild & string> {
-    type: "hasMany";
-    name: string;
-    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>;
-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[]>;
-interface MorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
-    type: "morphMany";
-    name: string;
-    localKey: LocalKey;
-    morphTypeKey: MorphTypeKey;
-    morphIdKey: MorphIdKey;
-    morphType: string;
-}
-interface MorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
-    type: "morphOne";
-    name: string;
-    localKey: LocalKey;
-    morphTypeKey: MorphTypeKey;
-    morphIdKey: MorphIdKey;
-    morphType: string;
-}
-interface MorphToRelation<TChild, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
-    type: "morphTo";
-    name: string;
-    morphTypeKey: MorphTypeKey;
-    morphIdKey: MorphIdKey;
-}
-declare function morphMany<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
-    name: string;
-    localKey: LocalKey;
-    morphTypeKey: MorphTypeKey;
-    morphIdKey: MorphIdKey;
-    morphType: string;
-}): MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>;
-declare function morphOne<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
-    name: string;
-    localKey: LocalKey;
-    morphTypeKey: MorphTypeKey;
-    morphIdKey: MorphIdKey;
-    morphType: string;
-}): MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>;
-declare function morphTo<TChild, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
-    name: string;
-    morphTypeKey: MorphTypeKey;
-    morphIdKey: MorphIdKey;
-}): MorphToRelation<TChild, MorphTypeKey, MorphIdKey>;
-declare function indexMorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild[]>;
-declare function indexMorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild | undefined>;
-declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<TParent[OwnerKey], TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, };

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

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

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

@@ -1,38 +0,0 @@
-import type { PaginatedResult } from "../pagination/index.ts";
-import type BaseRepository from "./baseRepository.ts";
-import type { BelongsToRelation, HasManyRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } 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(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;
-    withMorphMany<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphManyRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
-    withMorphOne<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphOneRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
-    withMorphTo<TParent extends object, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string, Alias extends string>(as: Alias, relation: MorphToRelation<TEntity, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, keyof TParent & string>>, 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 };