@getstrata/core 0.5.9 → 0.5.12

package/dist/index.js

@@ -942,6 +942,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) {
@@ -1145,6 +1205,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);
@@ -1205,6 +1296,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) => ({
@@ -1481,6 +1599,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/bindConnection.ts
@@ -2573,8 +2741,15 @@ function defineTable(definition) {
   return definition;
 }
 // ../../src/core/database/transaction.ts
+function supportsTransactions(connection) {
+  return typeof connection.begin === "function";
+}
 async function runInTransaction(operation) {
-  return await connection_default.begin(async (transaction) => {
+  const pool = resolveRepositoryConnection();
+  if (!supportsTransactions(pool)) {
+    throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
+  }
+  return await pool.begin(async (transaction) => {
     return await operation(createDatabaseConnection2(transaction));
   });
 }
@@ -2691,18 +2866,7 @@ async function defaultSmtpTransport(config, message) {
     await socket.write(`DATA\r
 `);
     await waitForSmtpResponse(readResponse, ["354"]);
-    const payload = [
-      `From: ${config.from}`,
-      `To: ${message.to}`,
-      `Subject: ${message.subject}`,
-      "MIME-Version: 1.0",
-      "Content-Type: text/plain; charset=utf-8",
-      "",
-      message.body,
-      ".",
-      ""
-    ].join(`\r
-`);
+    const payload = buildSmtpPayload(config.from, message);
     await socket.write(payload);
     await waitForSmtpResponse(readResponse, ["250"]);
     await socket.write(`QUIT\r
@@ -2712,6 +2876,30 @@ async function defaultSmtpTransport(config, message) {
     socket.end();
   }
 }
+function buildSmtpPayload(from, message) {
+  const headers = [`From: ${from}`, `To: ${message.to}`, `Subject: ${message.subject}`, "MIME-Version: 1.0"];
+  if (message.html) {
+    const boundary = `strata-${Date.now().toString(36)}`;
+    headers.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+    const parts = [
+      `--${boundary}`,
+      "Content-Type: text/plain; charset=utf-8",
+      "",
+      message.body,
+      `--${boundary}`,
+      "Content-Type: text/html; charset=utf-8",
+      "",
+      message.html,
+      `--${boundary}--`,
+      ""
+    ];
+    return [...headers, "", ...parts, ".", ""].join(`\r
+`);
+  }
+  headers.push("Content-Type: text/plain; charset=utf-8");
+  return [...headers, "", message.body, ".", ""].join(`\r
+`);
+}
 
 class LogMailDriver {
   async send(message) {
@@ -2720,7 +2908,8 @@ class LogMailDriver {
       channel: "mail",
       to: message.to,
       subject: message.subject,
-      body: message.body
+      body: message.body,
+      ...message.html ? { html: message.html } : {}
     }));
   }
 }
@@ -4860,6 +5049,147 @@ function resetGracefulShutdownForTests() {
   shutdownInstalled = false;
   shuttingDown = false;
 }
+// ../../src/core/mail/markdownMail.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function stripMarkdown(markdown) {
+  return markdown.replace(/^#{1,6}\s+/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/^[-*]\s+/gm, "\u2022 ").replace(/```[\s\S]*?```/g, "").replace(/\n{3,}/g, `
+
+`).trim();
+}
+function markdownToHtml(markdown) {
+  const escaped = markdown.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return escaped.replace(/^### (.+)$/gm, "<h3>$1</h3>").replace(/^## (.+)$/gm, "<h2>$1</h2>").replace(/^# (.+)$/gm, "<h1>$1</h1>").replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/\*([^*]+)\*/g, "<em>$1</em>").replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>').replace(/^[-*]\s+(.+)$/gm, "<li>$1</li>").replace(/(<li>[\s\S]*?<\/li>\n?)+/g, (block) => `<ul>${block}</ul>`).replace(/```(\w+)?\n([\s\S]*?)```/g, "<pre><code>$2</code></pre>").split(/\n\n+/).map((block) => {
+    if (block.startsWith("<")) {
+      return block;
+    }
+    return `<p>${block.replace(/\n/g, " ")}</p>`;
+  }).join(`
+`);
+}
+function wrapMarkdownMailLayout(bodyHtml, options = {}) {
+  const title = escapeHtml(options.title ?? "GetStrata");
+  const preview = escapeHtml(options.preview ?? "");
+  const footer = escapeHtml(options.footer ?? "Sent by GetStrata");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${title}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; line-height: 1.5; color: #111827; background: #f9fafb; margin: 0; padding: 24px; }
+    .container { max-width: 640px; margin: 0 auto; background: #ffffff; border: 1px solid #e5e7eb; border-radius: 8px; overflow: hidden; }
+    .header { padding: 20px 24px; border-bottom: 1px solid #e5e7eb; font-weight: 600; }
+    .content { padding: 24px; }
+    .footer { padding: 16px 24px; border-top: 1px solid #e5e7eb; color: #6b7280; font-size: 14px; }
+    a { color: #2563eb; }
+    code { background: #f3f4f6; padding: 2px 4px; border-radius: 4px; }
+    pre { background: #111827; color: #f9fafb; padding: 12px; border-radius: 6px; overflow-x: auto; }
+  </style>
+</head>
+<body>
+  ${preview ? `<span style="display:none;max-height:0;overflow:hidden;">${preview}</span>` : ""}
+  <div class="container">
+    <div class="header">${title}</div>
+    <div class="content">${bodyHtml}</div>
+    <div class="footer">${footer}</div>
+  </div>
+</body>
+</html>`;
+}
+function renderMarkdownMail(markdown, options = {}) {
+  const bodyHtml = markdownToHtml(markdown.trim());
+  const html = wrapMarkdownMailLayout(bodyHtml, options);
+  const text = stripMarkdown(markdown);
+  return { html, text };
+}
+// ../../src/core/mail/markdownMailable.ts
+function buildMarkdownMailMessage(input) {
+  const rendered = renderMarkdownMail(input.markdown, {
+    title: input.layout?.title ?? input.subject,
+    ...input.layout
+  });
+  return {
+    to: input.to,
+    subject: input.subject,
+    body: rendered.text,
+    html: rendered.html
+  };
+}
+async function sendMarkdownMail(mailer2, input) {
+  await mailer2.send(buildMarkdownMailMessage(input));
+}
+// ../../src/core/notifications/dispatcher.ts
+class NotificationDispatcher {
+  mailer;
+  databaseStore;
+  constructor(mailer2, databaseStore = null) {
+    this.mailer = mailer2;
+    this.databaseStore = databaseStore;
+  }
+  async send(notifiable, notification) {
+    for (const channel of notification.via(notifiable)) {
+      if (channel === "mail") {
+        await this.sendMail(notifiable, notification);
+        continue;
+      }
+      if (channel === "database") {
+        await this.sendDatabase(notifiable, notification);
+      }
+    }
+  }
+  async sendMail(notifiable, notification) {
+    const routed = notifiable.routeNotificationFor("mail");
+    if (routed === null) {
+      return;
+    }
+    const message = notification.toMail(notifiable);
+    if (!message) {
+      return;
+    }
+    if (message.markdown) {
+      await this.mailer.send(buildMarkdownMailMessage({
+        to: String(routed),
+        subject: message.subject,
+        markdown: message.markdown
+      }));
+      return;
+    }
+    await this.mailer.send({
+      to: String(routed),
+      subject: message.subject,
+      body: message.body ?? "",
+      ...message.html ? { html: message.html } : {}
+    });
+  }
+  async sendDatabase(notifiable, notification) {
+    if (!this.databaseStore) {
+      return;
+    }
+    const payload = notification.toDatabase(notifiable);
+    if (!payload) {
+      return;
+    }
+    await this.databaseStore.create({
+      userId: Number(notifiable.getNotificationKey()),
+      ...payload
+    });
+  }
+}
+function createNotificationDispatcher(mailer2, databaseStore) {
+  return new NotificationDispatcher(mailer2, databaseStore ?? null);
+}
+// ../../src/core/notifications/notification.ts
+class Notification {
+  toMail(_notifiable) {
+    return null;
+  }
+  toDatabase(_notifiable) {
+    return null;
+  }
+}
 // ../../src/core/queue/index.ts
 class Job {
   maxAttempts;
@@ -5363,6 +5693,7 @@ function validateObject(payload, schema) {
   return output;
 }
 export {
+  wrapMarkdownMailLayout,
   withMigrationLock,
   withMiddleware,
   withErrorHandling,
@@ -5370,10 +5701,12 @@ export {
   validateObject,
   toResourceCollection,
   toPaginatedResourceCollection,
+  stripMarkdown,
   stringRule,
   storageFacade as storage,
   setActiveApplicationContext,
   serializeDate,
+  sendMarkdownMail,
   securedBindRouteModelByKey,
   securedBindRouteModel,
   runWithDatabaseConnection,
@@ -5396,6 +5729,7 @@ export {
   resolveApplicationCache,
   resolveApplicationAuth,
   required,
+  renderMarkdownMail,
   registerShutdownHandler,
   registerModelRepository,
   readSubmittedCsrfTokenFromBody,
@@ -5409,9 +5743,13 @@ export {
   paginatedResponse,
   normalizeMetricPath,
   noContentResponse,
+  morphTo,
+  morphOne,
+  morphMany,
   minLength,
   migrateDatabase,
   maxLength,
+  markdownToHtml,
   mailer,
   mail,
   log,
@@ -5423,6 +5761,9 @@ export {
   isEtagEnabled,
   installGracefulShutdownSignals,
   inferReferencedTable,
+  indexMorphToRelation,
+  indexMorphOneRelation,
+  indexMorphManyRelation,
   indexHasOneRelation,
   indexHasManyRelation,
   indexBelongsToRelation,
@@ -5452,6 +5793,7 @@ export {
   createQueueWorker,
   createQueue,
   createProductionQueue,
+  createNotificationDispatcher,
   createMetricsMiddleware,
   createMemoryThrottleMiddleware,
   createLoginThrottleMiddleware,
@@ -5467,6 +5809,8 @@ export {
   composeMiddleware,
   compileBlueprint,
   cache,
+  buildSmtpPayload,
+  buildMarkdownMailMessage,
   bindDatabaseConnection2 as bindDatabaseConnection,
   belongsToMany,
   belongsTo,
@@ -5496,6 +5840,8 @@ export {
   PostgresGrammar,
   PolicyGate,
   Policy,
+  NotificationDispatcher,
+  Notification,
   NotFoundError,
   MySqlGrammar,
   Model,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.5.9",
+  "version": "0.5.12",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",