@getstrata/core 0.5.10 → 0.5.12

package/dist/entries/queue/publicQueue.js

@@ -664,6 +664,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) {
@@ -867,6 +927,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);
@@ -927,6 +1018,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) => ({
@@ -1203,6 +1321,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

package/dist/entries/queue/queueMetrics.js

@@ -1142,6 +1142,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/core/database/boundConnection.ts
 var boundConnectionHolder = {
@@ -1275,6 +1335,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);
@@ -1335,6 +1426,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) => ({
@@ -1611,6 +1729,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

package/dist/entries/view.js

@@ -873,6 +873,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) {
@@ -1076,6 +1136,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);
@@ -1136,6 +1227,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) => ({
@@ -1412,6 +1530,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

package/dist/framework/public-api.d.ts

@@ -21,8 +21,8 @@ export { freshDatabase, getMigrationStatus, loadMigrationsFromDirectory, migrate
 export type { Migration, MigrationDatabase, MigrationStatus, } from "../core/database/migrations/types.ts";
 export type { CastType, GlobalScopeFn, ModelConstructor } from "../core/database/model.ts";
 export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "../core/database/model.ts";
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "../core/database/relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "../core/database/relationships.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "../core/database/relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "../core/database/relationships.ts";
 export { RepositoryQuery } from "../core/database/repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "../core/database/schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "../core/database/schema/index.ts";
@@ -56,7 +56,13 @@ export { createThrottleMiddleware } from "../core/http/throttleMiddleware.ts";
 export { WebFormRequest } from "../core/http/webFormRequest.ts";
 export { installGracefulShutdownSignals, registerShutdownHandler, runGracefulShutdown, } from "../core/lifecycle/gracefulShutdown.ts";
 export type { MailDriver, MailMessage } from "../core/mail/mailer.ts";
-export { LogMailDriver, Mailer, mailer } from "../core/mail/mailer.ts";
+export { buildSmtpPayload, LogMailDriver, Mailer, mailer, } from "../core/mail/mailer.ts";
+export type { MarkdownMailLayoutOptions, RenderedMarkdownMail } from "../core/mail/markdownMail.ts";
+export { markdownToHtml, renderMarkdownMail, stripMarkdown, wrapMarkdownMailLayout, } from "../core/mail/markdownMail.ts";
+export type { MarkdownMailableInput } from "../core/mail/markdownMailable.ts";
+export { buildMarkdownMailMessage, sendMarkdownMail } from "../core/mail/markdownMailable.ts";
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "../core/notifications/index.ts";
+export { createNotificationDispatcher, Notification, NotificationDispatcher, } from "../core/notifications/index.ts";
 export type { MetricLabels } from "../core/metrics/prometheus.ts";
 export { PrometheusRegistry, prometheusRegistry } from "../core/metrics/prometheus.ts";
 export type { CursorPaginatedResult, PaginatedResult, PaginationMeta, } from "../core/pagination/index.ts";