@getstrata/core 0.5.51 → 0.5.53

package/dist/entries/facades.js

@@ -0,0 +1,378 @@
+// @bun
+// ../../src/core/facades/index.ts
+import { eventBus } from "@getstrata/core/events";
+import {
+  resolveApplicationAuth,
+  resolveApplicationCache,
+  resolveApplicationConfig,
+  resolveApplicationEventBus,
+  resolveApplicationLogger,
+  resolveApplicationPolicyGate,
+  resolveApplicationQueue
+} from "@getstrata/core/runtime/applicationRegistry";
+
+// ../../src/core/mail/mailer.ts
+function resolveSmtpConfig() {
+  const host = process.env.MAIL_HOST?.trim();
+  if (!host) {
+    throw new Error('MAIL_DRIVER="smtp" requires MAIL_HOST to be set.');
+  }
+  const from = process.env.MAIL_FROM?.trim();
+  if (!from) {
+    throw new Error('MAIL_DRIVER="smtp" requires MAIL_FROM to be set.');
+  }
+  const port = Number.parseInt(process.env.MAIL_PORT ?? "587", 10);
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error('Environment variable "MAIL_PORT" must be a positive integer.');
+  }
+  return {
+    host,
+    port,
+    from,
+    secure: (process.env.MAIL_SECURE ?? "false") === "true",
+    ...process.env.MAIL_USERNAME?.trim() ? { username: process.env.MAIL_USERNAME.trim() } : {},
+    ...process.env.MAIL_PASSWORD?.trim() ? { password: process.env.MAIL_PASSWORD.trim() } : {}
+  };
+}
+function encodeBase64(value) {
+  return Buffer.from(value, "utf8").toString("base64");
+}
+function parseSmtpResponses(buffer) {
+  const responses = [];
+  let remainder = buffer;
+  while (remainder.includes(`\r
+`)) {
+    const index = remainder.indexOf(`\r
+`);
+    const line = remainder.slice(0, index);
+    remainder = remainder.slice(index + 2);
+    if (line.length >= 4 && line[3] === "-") {
+      continue;
+    }
+    responses.push(line);
+  }
+  return { responses, remainder };
+}
+async function waitForSmtpResponse(readResponse, expectedCodes) {
+  const response = await readResponse();
+  const code = response.slice(0, 3);
+  if (!expectedCodes.includes(code)) {
+    throw new Error(`Unexpected SMTP response: ${response}`);
+  }
+  return response;
+}
+async function openSmtpConnection(config) {
+  let buffer = "";
+  const waiters = [];
+  const readResponse = () => new Promise((resolve, reject) => {
+    const parsed = parseSmtpResponses(buffer);
+    if (parsed.responses.length > 0) {
+      buffer = parsed.remainder;
+      resolve(parsed.responses.shift());
+      return;
+    }
+    waiters.push({ resolve, reject });
+  });
+  const socket = await Bun.connect({
+    hostname: config.host,
+    port: config.port,
+    socket: {
+      open() {},
+      data(_socket, chunk) {
+        buffer += Buffer.from(chunk).toString("utf8");
+        const parsed = parseSmtpResponses(buffer);
+        buffer = parsed.remainder;
+        while (parsed.responses.length > 0 && waiters.length > 0) {
+          const response = parsed.responses.shift();
+          waiters.shift()?.resolve(response);
+        }
+      },
+      error(_socket, error) {
+        const pending = waiters.splice(0);
+        for (const waiter of pending) {
+          waiter.reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    }
+  });
+  return { socket, readResponse };
+}
+async function defaultSmtpTransport(config, message) {
+  const { socket, readResponse } = await openSmtpConnection(config);
+  try {
+    await waitForSmtpResponse(readResponse, ["220"]);
+    await socket.write(`EHLO workhub.local\r
+`);
+    await waitForSmtpResponse(readResponse, ["250"]);
+    if (config.username && config.password) {
+      await socket.write(`AUTH LOGIN\r
+`);
+      await waitForSmtpResponse(readResponse, ["334"]);
+      await socket.write(`${encodeBase64(config.username)}\r
+`);
+      await waitForSmtpResponse(readResponse, ["334"]);
+      await socket.write(`${encodeBase64(config.password)}\r
+`);
+      await waitForSmtpResponse(readResponse, ["235"]);
+    }
+    await socket.write(`MAIL FROM:<${config.from}>\r
+`);
+    await waitForSmtpResponse(readResponse, ["250"]);
+    await socket.write(`RCPT TO:<${message.to}>\r
+`);
+    await waitForSmtpResponse(readResponse, ["250", "251"]);
+    await socket.write(`DATA\r
+`);
+    await waitForSmtpResponse(readResponse, ["354"]);
+    const payload = buildSmtpPayload(config.from, message);
+    await socket.write(payload);
+    await waitForSmtpResponse(readResponse, ["250"]);
+    await socket.write(`QUIT\r
+`);
+    await waitForSmtpResponse(readResponse, ["221"]);
+  } finally {
+    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) {
+    console.log(JSON.stringify({
+      level: "info",
+      channel: "mail",
+      to: message.to,
+      subject: message.subject,
+      body: message.body,
+      ...message.html ? { html: message.html } : {}
+    }));
+  }
+}
+
+class SmtpMailDriver {
+  config;
+  transport;
+  constructor(config, transport = defaultSmtpTransport) {
+    this.config = config;
+    this.transport = transport;
+  }
+  send(message) {
+    return this.transport(this.config, message);
+  }
+}
+
+class Mailer {
+  driver;
+  constructor(driver) {
+    this.driver = driver;
+  }
+  send(message) {
+    return this.driver.send(message);
+  }
+}
+function createMailDriver() {
+  const driver = process.env.MAIL_DRIVER ?? "log";
+  if (driver === "smtp") {
+    return new SmtpMailDriver(resolveSmtpConfig());
+  }
+  return new LogMailDriver;
+}
+var appMailer = new Mailer(createMailDriver());
+function mailer() {
+  return appMailer;
+}
+
+// ../../src/core/storage/storage.ts
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var {S3Client } = globalThis.Bun;
+
+class LocalStorageDriver {
+  rootDirectory;
+  constructor(rootDirectory) {
+    this.rootDirectory = rootDirectory;
+  }
+  resolveRootDirectory() {
+    return this.rootDirectory ?? process.env.STORAGE_PATH ?? "storage";
+  }
+  resolvePath(path) {
+    return join(this.resolveRootDirectory(), path.replace(/^\/+/, ""));
+  }
+  async put(path, contents) {
+    const absolutePath = this.resolvePath(path);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, contents);
+    return path;
+  }
+  async get(path) {
+    try {
+      return await readFile(this.resolvePath(path));
+    } catch {
+      return null;
+    }
+  }
+  async delete(path) {
+    try {
+      await unlink(this.resolvePath(path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+class S3StorageDriver {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async put(path, contents) {
+    await this.client.write(path.replace(/^\/+/, ""), contents);
+    return path;
+  }
+  async get(path) {
+    const normalizedPath = path.replace(/^\/+/, "");
+    const file = this.client.file(normalizedPath);
+    if (!await file.exists()) {
+      return null;
+    }
+    return new Uint8Array(await file.arrayBuffer());
+  }
+  async delete(path) {
+    try {
+      await this.client.unlink(path.replace(/^\/+/, ""));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+class StorageManager {
+  driver;
+  constructor(driver) {
+    this.driver = driver;
+  }
+  put(path, contents) {
+    return this.driver.put(path, contents);
+  }
+  get(path) {
+    return this.driver.get(path);
+  }
+  delete(path) {
+    return this.driver.delete(path);
+  }
+}
+function resolveS3Config() {
+  const accessKeyId = process.env.AWS_ACCESS_KEY_ID?.trim();
+  const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY?.trim();
+  const bucket = process.env.AWS_BUCKET?.trim();
+  if (!accessKeyId || !secretAccessKey || !bucket) {
+    throw new Error('STORAGE_DRIVER="s3" requires AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_BUCKET.');
+  }
+  return {
+    accessKeyId,
+    secretAccessKey,
+    bucket,
+    ...process.env.AWS_REGION?.trim() ? { region: process.env.AWS_REGION.trim() } : {},
+    ...process.env.AWS_ENDPOINT?.trim() ? { endpoint: process.env.AWS_ENDPOINT.trim() } : {}
+  };
+}
+function createS3Client(config = resolveS3Config()) {
+  return new S3Client({
+    accessKeyId: config.accessKeyId,
+    secretAccessKey: config.secretAccessKey,
+    bucket: config.bucket,
+    ...config.region ? { region: config.region } : {},
+    ...config.endpoint ? { endpoint: config.endpoint } : {}
+  });
+}
+function createStorageDriver() {
+  const driver = process.env.STORAGE_DRIVER ?? "local";
+  if (driver === "s3") {
+    return new S3StorageDriver(createS3Client());
+  }
+  return new LocalStorageDriver;
+}
+var defaultStorage = { current: null };
+function storage() {
+  if (!defaultStorage.current) {
+    defaultStorage.current = new StorageManager(createStorageDriver());
+  }
+  return defaultStorage.current;
+}
+function resetDefaultStorage() {
+  defaultStorage.current = null;
+}
+
+// ../../src/core/facades/index.ts
+function cache() {
+  return resolveApplicationCache();
+}
+function auth() {
+  return resolveApplicationAuth();
+}
+function policyGate() {
+  return resolveApplicationPolicyGate();
+}
+function queue() {
+  return resolveApplicationQueue();
+}
+function events() {
+  try {
+    return resolveApplicationEventBus();
+  } catch {
+    return eventBus;
+  }
+}
+function config(key) {
+  return resolveApplicationConfig().get(key);
+}
+function log() {
+  return resolveApplicationLogger();
+}
+function mail() {
+  return mailer();
+}
+function storageFacade() {
+  return storage();
+}
+export {
+  storageFacade as storage,
+  queue,
+  policyGate,
+  mail,
+  log,
+  events,
+  config,
+  cache,
+  auth
+};

package/dist/entries/http/formRequest.js

@@ -6,12 +6,65 @@ import { ForbiddenError } from "@getstrata/core/errors/http";
 import { currentAuthUser } from "@getstrata/core/auth/authContext";
 import { BadRequestError } from "@getstrata/core/errors/http";
 import { currentTenantId } from "@getstrata/core/tenant/tenantContext";
+function buildRequestCacheKey(fallbackPath, request) {
+  if (!request) {
+    return fallbackPath;
+  }
+  const url = new URL(request.url);
+  const user = currentAuthUser();
+  const authScope = user ? `u:${user.id}` : "guest";
+  const tenantScope = `t:${currentTenantId()}`;
+  return `${authScope}|${tenantScope}|${url.pathname}${url.search}`;
+}
 function getQueryParams(request) {
   if (!request) {
     return new URLSearchParams;
   }
   return new URL(request.url).searchParams;
 }
+function parseOptionalPositiveIntQueryParam(params, name) {
+  const value = params.get(name);
+  if (value === null || value.trim() === "") {
+    return;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new BadRequestError(`Invalid query parameter "${name}". Expected a positive integer.`);
+  }
+  return parsed;
+}
+function parseOptionalBooleanQueryParam(params, name) {
+  const value = params.get(name);
+  if (value === null || value.trim() === "") {
+    return;
+  }
+  switch (value.toLowerCase()) {
+    case "true":
+    case "1":
+      return true;
+    case "false":
+    case "0":
+      return false;
+    default:
+      throw new BadRequestError(`Invalid query parameter "${name}". Expected a boolean.`);
+  }
+}
+function parseOptionalEnumQueryParam(params, name, allowedValues) {
+  const value = params.get(name);
+  if (value === null || value.trim() === "") {
+    return;
+  }
+  if (!allowedValues.includes(value)) {
+    throw new BadRequestError(`Invalid query parameter "${name}". Expected one of: ${allowedValues.join(", ")}.`);
+  }
+  return value;
+}
+function expectObject(value, label = "request body") {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new BadRequestError(`${label} must be a JSON object.`);
+  }
+  return value;
+}
 async function parseJsonBody(request, validator) {
   let payload;
   try {
@@ -21,6 +74,55 @@ async function parseJsonBody(request, validator) {
   }
   return validator(payload);
 }
+function readRequiredString(payload, field, options = {}) {
+  const value = payload[field];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new BadRequestError(`"${field}" is required and must be a string.`);
+  }
+  const trimmed = value.trim();
+  if (options.minLength !== undefined && trimmed.length < options.minLength) {
+    throw new BadRequestError(`"${field}" must be at least ${options.minLength} characters.`);
+  }
+  if (options.maxLength !== undefined && trimmed.length > options.maxLength) {
+    throw new BadRequestError(`"${field}" must be at most ${options.maxLength} characters.`);
+  }
+  if (options.pattern && !options.pattern.test(trimmed)) {
+    throw new BadRequestError(`"${field}" has an invalid format.`);
+  }
+  return trimmed;
+}
+function readOptionalString(payload, field, options = {}) {
+  if (!(field in payload) || payload[field] === undefined) {
+    return;
+  }
+  return readRequiredString(payload, field, options);
+}
+function readRequiredEnum(payload, field, allowedValues) {
+  const value = readRequiredString(payload, field);
+  if (!allowedValues.includes(value)) {
+    throw new BadRequestError(`"${field}" must be one of: ${allowedValues.join(", ")}.`);
+  }
+  return value;
+}
+function readOptionalEnum(payload, field, allowedValues) {
+  if (!(field in payload) || payload[field] === undefined) {
+    return;
+  }
+  return readRequiredEnum(payload, field, allowedValues);
+}
+function readRequiredPositiveInt(payload, field) {
+  const value = payload[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new BadRequestError(`"${field}" is required and must be a positive integer.`);
+  }
+  return value;
+}
+function readOptionalPositiveInt(payload, field) {
+  if (!(field in payload) || payload[field] === undefined) {
+    return;
+  }
+  return readRequiredPositiveInt(payload, field);
+}
 function parsePositiveIntParam(value, name = "id") {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isInteger(parsed) || parsed <= 0) {

package/dist/entries/http/pagination.js

@@ -17,12 +17,65 @@ function buildPaginationMeta(input) {
 import { currentAuthUser } from "@getstrata/core/auth/authContext";
 import { BadRequestError } from "@getstrata/core/errors/http";
 import { currentTenantId } from "@getstrata/core/tenant/tenantContext";
+function buildRequestCacheKey(fallbackPath, request) {
+  if (!request) {
+    return fallbackPath;
+  }
+  const url = new URL(request.url);
+  const user = currentAuthUser();
+  const authScope = user ? `u:${user.id}` : "guest";
+  const tenantScope = `t:${currentTenantId()}`;
+  return `${authScope}|${tenantScope}|${url.pathname}${url.search}`;
+}
 function getQueryParams(request) {
   if (!request) {
     return new URLSearchParams;
   }
   return new URL(request.url).searchParams;
 }
+function parseOptionalPositiveIntQueryParam(params, name) {
+  const value = params.get(name);
+  if (value === null || value.trim() === "") {
+    return;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new BadRequestError(`Invalid query parameter "${name}". Expected a positive integer.`);
+  }
+  return parsed;
+}
+function parseOptionalBooleanQueryParam(params, name) {
+  const value = params.get(name);
+  if (value === null || value.trim() === "") {
+    return;
+  }
+  switch (value.toLowerCase()) {
+    case "true":
+    case "1":
+      return true;
+    case "false":
+    case "0":
+      return false;
+    default:
+      throw new BadRequestError(`Invalid query parameter "${name}". Expected a boolean.`);
+  }
+}
+function parseOptionalEnumQueryParam(params, name, allowedValues) {
+  const value = params.get(name);
+  if (value === null || value.trim() === "") {
+    return;
+  }
+  if (!allowedValues.includes(value)) {
+    throw new BadRequestError(`Invalid query parameter "${name}". Expected one of: ${allowedValues.join(", ")}.`);
+  }
+  return value;
+}
+function expectObject(value, label = "request body") {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new BadRequestError(`${label} must be a JSON object.`);
+  }
+  return value;
+}
 async function parseJsonBody(request, validator) {
   let payload;
   try {
@@ -32,6 +85,55 @@ async function parseJsonBody(request, validator) {
   }
   return validator(payload);
 }
+function readRequiredString(payload, field, options = {}) {
+  const value = payload[field];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new BadRequestError(`"${field}" is required and must be a string.`);
+  }
+  const trimmed = value.trim();
+  if (options.minLength !== undefined && trimmed.length < options.minLength) {
+    throw new BadRequestError(`"${field}" must be at least ${options.minLength} characters.`);
+  }
+  if (options.maxLength !== undefined && trimmed.length > options.maxLength) {
+    throw new BadRequestError(`"${field}" must be at most ${options.maxLength} characters.`);
+  }
+  if (options.pattern && !options.pattern.test(trimmed)) {
+    throw new BadRequestError(`"${field}" has an invalid format.`);
+  }
+  return trimmed;
+}
+function readOptionalString(payload, field, options = {}) {
+  if (!(field in payload) || payload[field] === undefined) {
+    return;
+  }
+  return readRequiredString(payload, field, options);
+}
+function readRequiredEnum(payload, field, allowedValues) {
+  const value = readRequiredString(payload, field);
+  if (!allowedValues.includes(value)) {
+    throw new BadRequestError(`"${field}" must be one of: ${allowedValues.join(", ")}.`);
+  }
+  return value;
+}
+function readOptionalEnum(payload, field, allowedValues) {
+  if (!(field in payload) || payload[field] === undefined) {
+    return;
+  }
+  return readRequiredEnum(payload, field, allowedValues);
+}
+function readRequiredPositiveInt(payload, field) {
+  const value = payload[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new BadRequestError(`"${field}" is required and must be a positive integer.`);
+  }
+  return value;
+}
+function readOptionalPositiveInt(payload, field) {
+  if (!(field in payload) || payload[field] === undefined) {
+    return;
+  }
+  return readRequiredPositiveInt(payload, field);
+}
 function parsePositiveIntParam(value, name = "id") {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isInteger(parsed) || parsed <= 0) {