@getstrata/core 0.5.10 → 0.5.13

package/dist/core/admin/formatValue.d.ts

@@ -0,0 +1,3 @@
+import type { AdminColumnType } from "./types.ts";
+declare function formatAdminValue(value: unknown, type?: AdminColumnType): string;
+export { formatAdminValue };

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

@@ -0,0 +1,3 @@
+export { formatAdminValue } from "./formatValue.ts";
+export { AdminResourceRegistry } from "./registry.ts";
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, } from "./types.ts";

package/dist/core/admin/registry.d.ts

@@ -0,0 +1,10 @@
+import type { AdminResource, AdminResourceDefinition } from "./types.ts";
+declare class AdminResourceRegistry {
+    private readonly resources;
+    register<TEntity extends object>(resource: AdminResource<TEntity>): void;
+    get(name: string): AdminResource<object> | undefined;
+    list(): AdminResourceDefinition[];
+    all(): AdminResource<object>[];
+    clear(): void;
+}
+export { AdminResourceRegistry };

package/dist/core/admin/types.d.ts

@@ -0,0 +1,24 @@
+import type { PaginatedResult } from "../pagination/index.ts";
+type AdminColumnType = "text" | "number" | "boolean" | "datetime" | "code";
+interface AdminColumn {
+    key: string;
+    label: string;
+    type?: AdminColumnType;
+}
+interface AdminResourceHandlers<TEntity extends object> {
+    paginate(options: {
+        page: number;
+        perPage: number;
+    }): Promise<PaginatedResult<TEntity>>;
+    findById?(id: number): Promise<TEntity | null>;
+}
+interface AdminResourceDefinition {
+    name: string;
+    label: string;
+    labelPlural: string;
+    columns: AdminColumn[];
+}
+interface AdminResource<TEntity extends object> extends AdminResourceDefinition {
+    handlers: AdminResourceHandlers<TEntity>;
+}
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, };

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

@@ -1,5 +1,5 @@
 import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
-import { type BelongsToRelation, type HasManyRelation } from "./relationships.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";
@@ -54,6 +54,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     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 };

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

@@ -5,8 +5,8 @@ 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, } from "./relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "./relationships.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";

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

@@ -52,5 +52,49 @@ declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TP
 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[]>;
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation };
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, };
+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/repositoryQuery.d.ts

@@ -1,6 +1,6 @@
 import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
-import type { BelongsToRelation, HasManyRelation } from "./relationships.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>;
@@ -22,6 +22,9 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     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: {

package/dist/core/mail/mailer.d.ts

@@ -2,6 +2,7 @@ interface MailMessage {
     to: string;
     subject: string;
     body: string;
+    html?: string;
 }
 interface MailDriver {
     send(message: MailMessage): Promise<void>;
@@ -16,6 +17,7 @@ interface SmtpConfig {
 }
 type SmtpTransport = (config: SmtpConfig, message: MailMessage) => Promise<void>;
 declare function resolveSmtpConfig(): SmtpConfig;
+declare function buildSmtpPayload(from: string, message: MailMessage): string;
 declare class LogMailDriver implements MailDriver {
     send(message: MailMessage): Promise<void>;
 }
@@ -33,4 +35,4 @@ declare class Mailer {
 declare function createMailDriver(): MailDriver;
 declare function mailer(): Mailer;
 export type { MailDriver, MailMessage, SmtpConfig, SmtpTransport };
-export { createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver };
+export { buildSmtpPayload, createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver, };

package/dist/core/mail/markdownMail.d.ts

@@ -0,0 +1,15 @@
+interface MarkdownMailLayoutOptions {
+    title?: string;
+    preview?: string;
+    footer?: string;
+}
+interface RenderedMarkdownMail {
+    html: string;
+    text: string;
+}
+declare function stripMarkdown(markdown: string): string;
+declare function markdownToHtml(markdown: string): string;
+declare function wrapMarkdownMailLayout(bodyHtml: string, options?: MarkdownMailLayoutOptions): string;
+declare function renderMarkdownMail(markdown: string, options?: MarkdownMailLayoutOptions): RenderedMarkdownMail;
+export type { MarkdownMailLayoutOptions, RenderedMarkdownMail };
+export { markdownToHtml, renderMarkdownMail, stripMarkdown, wrapMarkdownMailLayout };

package/dist/core/mail/markdownMailable.d.ts

@@ -0,0 +1,12 @@
+import type { Mailer, MailMessage } from "./mailer.ts";
+import { type MarkdownMailLayoutOptions } from "./markdownMail.ts";
+interface MarkdownMailableInput {
+    to: string;
+    subject: string;
+    markdown: string;
+    layout?: MarkdownMailLayoutOptions;
+}
+declare function buildMarkdownMailMessage(input: MarkdownMailableInput): MailMessage;
+declare function sendMarkdownMail(mailer: Mailer, input: MarkdownMailableInput): Promise<void>;
+export type { MarkdownMailableInput };
+export { buildMarkdownMailMessage, sendMarkdownMail };

package/dist/core/notifications/dispatcher.d.ts

@@ -0,0 +1,13 @@
+import type { Mailer } from "../mail/mailer.ts";
+import type { Notification } from "./notification.ts";
+import type { DatabaseNotificationStore, Notifiable } from "./types.ts";
+declare class NotificationDispatcher {
+    private readonly mailer;
+    private readonly databaseStore;
+    constructor(mailer: Mailer, databaseStore?: DatabaseNotificationStore | null);
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+    private sendMail;
+    private sendDatabase;
+}
+declare function createNotificationDispatcher(mailer: Mailer, databaseStore?: DatabaseNotificationStore): NotificationDispatcher;
+export { createNotificationDispatcher, NotificationDispatcher };

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

@@ -0,0 +1,3 @@
+export { createNotificationDispatcher, NotificationDispatcher } from "./dispatcher.ts";
+export { Notification } from "./notification.ts";
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "./types.ts";

package/dist/core/notifications/notification.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseNotificationPayload, MailNotificationMessage, NotificationChannelName } from "./types.ts";
+declare abstract class Notification<TNotifiable = unknown> {
+    via(_notifiable: TNotifiable): NotificationChannelName[];
+    toMail(_notifiable: TNotifiable): MailNotificationMessage | null;
+    toDatabase(_notifiable: TNotifiable): DatabaseNotificationPayload | null;
+}
+export { Notification };

package/dist/core/notifications/types.d.ts

@@ -0,0 +1,25 @@
+type NotificationChannelName = "mail" | "database";
+interface MailNotificationMessage {
+    subject: string;
+    markdown?: string;
+    body?: string;
+    html?: string;
+}
+interface DatabaseNotificationPayload {
+    type: string;
+    title: string;
+    body: string;
+    data?: Record<string, unknown>;
+    notifiableType?: string | null;
+    notifiableId?: number | null;
+}
+interface DatabaseNotificationStore {
+    create(input: DatabaseNotificationPayload & {
+        userId: number;
+    }): Promise<Record<string, unknown>>;
+}
+interface Notifiable {
+    getNotificationKey(): string | number;
+    routeNotificationFor(channel: NotificationChannelName): string | number | null;
+}
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, };

package/dist/core/queue/failedJobService.d.ts

@@ -10,6 +10,7 @@ declare class FailedJobService {
     }): Promise<FailedJobRecord>;
     listRecent(limit?: number): Promise<FailedJobRecord[]>;
     retry(id: number): Promise<FailedJobRecord>;
+    delete(id: number): Promise<void>;
     flush(): Promise<number>;
 }
 export default FailedJobService;

package/dist/core/queue/publicQueue.d.ts

@@ -2,6 +2,7 @@ import FailedJobRepository from "./failedJobRepository.ts";
 import FailedJobService from "./failedJobService.ts";
 import type { Job, Queue } from "./index.ts";
 import { jobRegistry } from "./jobRegistry.ts";
+import { runQueueJob } from "./jobRunner.ts";
 import { QueueWorker, RedisQueue } from "./redisQueue.ts";
 import { ResilientQueue } from "./resilientQueue.ts";
 declare function createFailedJobService(): FailedJobService;
@@ -12,4 +13,4 @@ declare function createProductionQueue(driver: "sync" | "async" | "redis", optio
     registerJobs?: () => void;
 }): Queue;
 declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker;
-export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, };
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, runQueueJob, };

package/dist/entries/auth/guard.js

@@ -866,6 +866,66 @@ function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   }
   return groups;
 }
+function morphMany(definition) {
+  return {
+    type: "morphMany",
+    ...definition
+  };
+}
+function morphOne(definition) {
+  return {
+    type: "morphOne",
+    ...definition
+  };
+}
+function morphTo(definition) {
+  return {
+    type: "morphTo",
+    ...definition
+  };
+}
+function indexMorphManyRelation(parents, children, relation) {
+  const groups = new Map;
+  for (const parent of parents) {
+    groups.set(parent[relation.localKey], []);
+  }
+  for (const child of children) {
+    if (child[relation.morphTypeKey] !== relation.morphType) {
+      continue;
+    }
+    const key = child[relation.morphIdKey];
+    const group = groups.get(key);
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  return groups;
+}
+function indexMorphOneRelation(parents, children, relation) {
+  const grouped = indexMorphManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexMorphToRelation(children, parentsByType, relation) {
+  const result = new Map;
+  for (const child of children) {
+    const morphType = String(child[relation.morphTypeKey]);
+    const parents = parentsByType.get(morphType);
+    if (!parents) {
+      continue;
+    }
+    const parent = parents.get(child[relation.morphIdKey]);
+    if (parent) {
+      result.set(child[relation.morphIdKey], parent);
+    }
+  }
+  return result;
+}
 
 // ../../src/config/database.ts
 function readInteger(name, fallback) {
@@ -1069,6 +1129,37 @@ class RepositoryQuery {
     });
     return this;
   }
+  withMorphMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withMorphOne(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphOne",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withMorphTo(as, relation, repositoriesByType, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphTo",
+      as,
+      relation,
+      repository: this.repository,
+      morphRepositories: repositoriesByType,
+      options
+    });
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -1129,6 +1220,33 @@ class RepositoryQuery {
         }));
         continue;
       }
+      if (load.kind === "morphMany") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
+      if (load.kind === "morphOne") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey])
+        }));
+        continue;
+      }
+      if (load.kind === "morphTo") {
+        const relation2 = load.relation;
+        const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.morphIdKey])
+        }));
+        continue;
+      }
       const relation = load.relation;
       const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
       result = result.map((row) => ({
@@ -1405,6 +1523,56 @@ class BaseRepository {
     }, options);
     return indexBelongsToRelation(children, parents, relation);
   }
+  async loadMorphManyForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexMorphManyRelation(parents, [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const children = await this.findWhere({
+      [relation.morphTypeKey]: relation.morphType,
+      [relation.morphIdKey]: parentIds
+    }, options);
+    return indexMorphManyRelation(parents, children, relation);
+  }
+  async loadMorphOneForParents(parents, relation, options = {}) {
+    const grouped = await this.loadMorphManyForParents(parents, relation, options);
+    const result = new Map;
+    for (const parent of parents) {
+      const matches = grouped.get(parent[relation.localKey]) ?? [];
+      result.set(parent[relation.localKey], matches[0]);
+    }
+    return result;
+  }
+  async loadMorphToForChildren(children, relation, repositoriesByType, options = {}) {
+    if (children.length === 0) {
+      return new Map;
+    }
+    const idsByType = new Map;
+    for (const child of children) {
+      const morphType = String(child[relation.morphTypeKey]);
+      const morphId = child[relation.morphIdKey];
+      const ids = idsByType.get(morphType) ?? new Set;
+      ids.add(morphId);
+      idsByType.set(morphType, ids);
+    }
+    const parentsByType = new Map;
+    for (const [morphType, ids] of idsByType) {
+      const repository = repositoriesByType.get(morphType);
+      if (!repository) {
+        continue;
+      }
+      const ownerKey = repository.getTable().primaryKey;
+      const parents = await repository.withConnection(this.connection).findWhere({
+        [ownerKey]: [...ids]
+      }, options);
+      const indexed = new Map;
+      for (const parent of parents) {
+        indexed.set(parent[ownerKey], parent);
+      }
+      parentsByType.set(morphType, indexed);
+    }
+    return indexMorphToRelation(children, parentsByType, relation);
+  }
 }
 var baseRepository_default = BaseRepository;
 // ../../src/core/database/connection.ts