@getstrata/core 1.1.9 → 2.0.0

package/dist/entries/database/migrations.js

@@ -26,14 +26,6 @@ function createAsyncContextStore(key) {
 }
 var init_asyncContextStore = () => {};
 
-// ../../src/core/database/migrations/runner.ts
-import { readdir } from "fs/promises";
-import { join } from "path";
-import { pathToFileURL } from "url";
-
-// ../../src/core/database/dialect.ts
-init_asyncContextStore();
-
 // ../../src/core/database/schema/driver.ts
 function normalizeConnectionName(connection) {
   const normalized = connection.trim().toLowerCase();
@@ -73,6 +65,7 @@ function resolveDatabaseDriver(options = {}) {
   }
   return "pgsql";
 }
+var init_driver = () => {};
 
 // ../../src/core/database/dialect.ts
 function assertSafeIdentifier(identifier) {
@@ -84,133 +77,143 @@ function assertSafeIdentifier(identifier) {
 function quoteIdentifierFor(dialect, column) {
   return dialect.quoteIdentifier(column);
 }
-var postgresDialect = {
-  driver: "pgsql",
-  placeholder(index) {
-    return `$${index}`;
-  },
-  quoteIdentifier(identifier) {
-    return `"${assertSafeIdentifier(identifier)}"`;
-  },
-  nowExpression() {
-    return "NOW()";
-  },
-  timestampValue(value) {
-    return value.toISOString();
-  },
-  returningClause(columns) {
-    return ` RETURNING ${columns}`;
-  },
-  ilikeOperator() {
-    return "ILIKE";
-  },
-  nullsLastSuffix() {
-    return " NULLS LAST";
-  },
-  castToText(expression) {
-    return `${expression}::text`;
-  },
-  upsertSuffix(conflictColumns, updateColumns) {
-    const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
-    if (updateColumns.length === 0) {
-      return ` ON CONFLICT (${target}) DO NOTHING`;
-    }
-    const assignments = updateColumns.map((column) => {
-      const quoted = quoteIdentifierFor(this, column);
-      return `${quoted} = excluded.${quoted}`;
-    }).join(", ");
-    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
-  }
-};
-var mysqlDialect = {
-  driver: "mysql",
-  placeholder() {
-    return "?";
-  },
-  quoteIdentifier(identifier) {
-    return `\`${assertSafeIdentifier(identifier)}\``;
-  },
-  nowExpression() {
-    return "CURRENT_TIMESTAMP";
-  },
-  timestampValue(value) {
-    return value.toISOString().slice(0, 19).replace("T", " ");
-  },
-  returningClause() {
-    return "";
-  },
-  ilikeOperator() {
-    return "LIKE";
-  },
-  nullsLastSuffix() {
-    return "";
-  },
-  castToText(expression) {
-    return `CAST(${expression} AS CHAR)`;
-  },
-  upsertSuffix(conflictColumns, updateColumns) {
-    if (updateColumns.length === 0) {
-      const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
-      return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
-    }
-    const assignments = updateColumns.map((column) => {
-      const quoted = quoteIdentifierFor(this, column);
-      return `${quoted} = VALUES(${quoted})`;
-    }).join(", ");
-    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
-  }
-};
-var sqliteDialect = {
-  driver: "sqlite",
-  placeholder() {
-    return "?";
-  },
-  quoteIdentifier(identifier) {
-    return `"${assertSafeIdentifier(identifier)}"`;
-  },
-  nowExpression() {
-    return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
-  },
-  timestampValue(value) {
-    return value.toISOString();
-  },
-  returningClause(columns) {
-    return ` RETURNING ${columns}`;
-  },
-  ilikeOperator() {
-    return "LIKE";
-  },
-  nullsLastSuffix() {
-    return "";
-  },
-  castToText(expression) {
-    return `CAST(${expression} AS TEXT)`;
-  },
-  upsertSuffix(conflictColumns, updateColumns) {
-    const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
-    if (updateColumns.length === 0) {
-      return ` ON CONFLICT (${target}) DO NOTHING`;
-    }
-    const assignments = updateColumns.map((column) => {
-      const quoted = quoteIdentifierFor(this, column);
-      return `${quoted} = excluded.${quoted}`;
-    }).join(", ");
-    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
-  }
-};
-var dialects = {
-  pgsql: postgresDialect,
-  mysql: mysqlDialect,
-  sqlite: sqliteDialect
-};
-var dialectContext = createAsyncContextStore("@getstrata/sqlDialect");
-var dialectOverride = null;
 function dialectFor(driver) {
   return dialects[driver];
 }
 function currentSqlDialect() {
   return dialectContext.getStore() ?? dialectOverride ?? dialectFor(resolveDatabaseDriver());
 }
+var postgresDialect, mysqlDialect, sqliteDialect, dialects, dialectContext, dialectOverride = null;
+var init_dialect = __esm(() => {
+  init_asyncContextStore();
+  init_driver();
+  postgresDialect = {
+    driver: "pgsql",
+    placeholder(index) {
+      return `$${index}`;
+    },
+    quoteIdentifier(identifier) {
+      return `"${assertSafeIdentifier(identifier)}"`;
+    },
+    nowExpression() {
+      return "NOW()";
+    },
+    timestampValue(value) {
+      return value.toISOString();
+    },
+    returningClause(columns) {
+      return ` RETURNING ${columns}`;
+    },
+    ilikeOperator() {
+      return "ILIKE";
+    },
+    nullsLastSuffix() {
+      return " NULLS LAST";
+    },
+    castToText(expression) {
+      return `${expression}::text`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+      if (updateColumns.length === 0) {
+        return ` ON CONFLICT (${target}) DO NOTHING`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = excluded.${quoted}`;
+      }).join(", ");
+      return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+    }
+  };
+  mysqlDialect = {
+    driver: "mysql",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `\`${assertSafeIdentifier(identifier)}\``;
+    },
+    nowExpression() {
+      return "CURRENT_TIMESTAMP";
+    },
+    timestampValue(value) {
+      return value.toISOString().slice(0, 19).replace("T", " ");
+    },
+    returningClause() {
+      return "";
+    },
+    ilikeOperator() {
+      return "LIKE";
+    },
+    nullsLastSuffix() {
+      return "";
+    },
+    castToText(expression) {
+      return `CAST(${expression} AS CHAR)`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      if (updateColumns.length === 0) {
+        const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
+        return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = VALUES(${quoted})`;
+      }).join(", ");
+      return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+    }
+  };
+  sqliteDialect = {
+    driver: "sqlite",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `"${assertSafeIdentifier(identifier)}"`;
+    },
+    nowExpression() {
+      return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
+    },
+    timestampValue(value) {
+      return value.toISOString();
+    },
+    returningClause(columns) {
+      return ` RETURNING ${columns}`;
+    },
+    ilikeOperator() {
+      return "LIKE";
+    },
+    nullsLastSuffix() {
+      return "";
+    },
+    castToText(expression) {
+      return `CAST(${expression} AS TEXT)`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+      if (updateColumns.length === 0) {
+        return ` ON CONFLICT (${target}) DO NOTHING`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = excluded.${quoted}`;
+      }).join(", ");
+      return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+    }
+  };
+  dialects = {
+    pgsql: postgresDialect,
+    mysql: mysqlDialect,
+    sqlite: sqliteDialect
+  };
+  dialectContext = createAsyncContextStore("@getstrata/sqlDialect");
+});
+
+// ../../src/core/database/migrations/runner.ts
+init_dialect();
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
 
 // ../../src/core/database/migrations/advisoryLock.ts
 var MIGRATION_LOCK_KEY = 42424242;

package/dist/entries/database/schema.js

@@ -1,4 +1,57 @@
 // @bun
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
+var init_driver = () => {};
+
 // ../../src/core/database/schema/columnDefinition.ts
 class ColumnDefinition {
   name;
@@ -220,45 +273,10 @@ class Blueprint {
     });
   }
 }
-// ../../src/core/database/schema/driver.ts
-function normalizeConnectionName(connection) {
-  const normalized = connection.trim().toLowerCase();
-  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
-    return "pgsql";
-  }
-  if (normalized === "mysql" || normalized === "mariadb") {
-    return "mysql";
-  }
-  if (normalized === "sqlite") {
-    return "sqlite";
-  }
-  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
-}
-function resolveDriverFromUrl(url) {
-  const normalized = url.trim().toLowerCase();
-  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
-    return "pgsql";
-  }
-  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
-    return "mysql";
-  }
-  if (normalized.startsWith("sqlite:")) {
-    return "sqlite";
-  }
-  return null;
-}
-function resolveDatabaseDriver(options = {}) {
-  const connection = options.connection ?? process.env.DB_CONNECTION;
-  if (connection) {
-    return normalizeConnectionName(connection);
-  }
-  const url = options.url ?? process.env.DATABASE_URL ?? "";
-  const fromUrl = resolveDriverFromUrl(url);
-  if (fromUrl) {
-    return fromUrl;
-  }
-  return "pgsql";
-}
+
+// ../../src/core/database/schema/index.ts
+init_driver();
+
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -1084,6 +1102,7 @@ function grammarForDriver(driver) {
   }
 }
 // ../../src/core/database/schema/schema.ts
+init_driver();
 class SchemaBuilder {
   #driver;
   #statements = [];

package/dist/entries/http/metricsMiddleware.js

@@ -1,6 +1,50 @@
 // @bun
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+var init_asyncContextStore = () => {};
+
 // ../../src/core/metrics/prometheus.ts
+var HTTP_DURATION_BUCKETS_MS = [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 1e4];
+function emptyHistogram() {
+  return {
+    cumulative: HTTP_DURATION_BUCKETS_MS.map(() => 0),
+    sum: 0,
+    count: 0
+  };
+}
+
 class PrometheusRegistry {
+  maxSeries;
+  seriesLabels = new Map;
+  constructor(maxSeries = 4096) {
+    this.maxSeries = maxSeries;
+    if (!Number.isSafeInteger(maxSeries) || maxSeries < 1) {
+      throw new Error("Metrics maxSeries must be a positive safe integer.");
+    }
+  }
   httpRequestsTotal = new Map;
   httpRequestDurationMs = new Map;
   incrementHttpRequest(labels) {
@@ -8,10 +52,20 @@ class PrometheusRegistry {
     this.httpRequestsTotal.set(key, (this.httpRequestsTotal.get(key) ?? 0) + 1);
   }
   observeHttpDuration(labels, durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs < 0)
+      return;
     const key = this.metricKey(labels);
-    const samples = this.httpRequestDurationMs.get(key) ?? [];
-    samples.push(durationMs);
-    this.httpRequestDurationMs.set(key, samples);
+    const histogram = this.httpRequestDurationMs.get(key) ?? emptyHistogram();
+    histogram.count += 1;
+    histogram.sum += durationMs;
+    for (let index = 0;index < HTTP_DURATION_BUCKETS_MS.length; index += 1) {
+      const bound = HTTP_DURATION_BUCKETS_MS[index];
+      if (bound !== undefined && durationMs <= bound) {
+        const count = histogram.cumulative[index] ?? 0;
+        histogram.cumulative[index] = count + 1;
+      }
+    }
+    this.httpRequestDurationMs.set(key, histogram);
   }
   renderMetrics() {
     const lines = [
@@ -21,16 +75,22 @@ class PrometheusRegistry {
     for (const [key, value] of this.httpRequestsTotal) {
       lines.push(`http_requests_total{${key}} ${value}`);
     }
-    lines.push("# HELP http_request_duration_ms_sum Sum of HTTP request durations in milliseconds.", "# TYPE http_request_duration_ms_sum counter");
-    for (const [key, samples] of this.httpRequestDurationMs) {
-      const sum = samples.reduce((total, sample) => total + sample, 0);
-      lines.push(`http_request_duration_ms_sum{${key}} ${sum}`);
+    lines.push("# HELP http_request_duration_ms HTTP request duration in milliseconds.", "# TYPE http_request_duration_ms histogram");
+    for (const [key, histogram] of this.httpRequestDurationMs) {
+      for (let index = 0;index < HTTP_DURATION_BUCKETS_MS.length; index += 1) {
+        const bound = HTTP_DURATION_BUCKETS_MS[index];
+        lines.push(`http_request_duration_ms_bucket{${key},le="${bound}"} ${histogram.cumulative[index] ?? 0}`);
+      }
+      lines.push(`http_request_duration_ms_bucket{${key},le="+Inf"} ${histogram.count}`);
+      lines.push(`http_request_duration_ms_sum{${key}} ${histogram.sum}`);
+      lines.push(`http_request_duration_ms_count{${key}} ${histogram.count}`);
     }
     return `${lines.join(`
 `)}
 `;
   }
   resetForTests() {
+    this.seriesLabels.clear();
     this.httpRequestsTotal.clear();
     this.httpRequestDurationMs.clear();
   }
@@ -40,9 +100,10 @@ class PrometheusRegistry {
     let totalRequests = 0;
     for (const [key, count] of this.httpRequestsTotal) {
       totalRequests += count;
-      const method = key.match(/method="([^"]+)"/)?.[1] ?? "GET";
-      const path = key.match(/path="([^"]+)"/)?.[1] ?? "/";
-      const status = key.match(/status="([^"]+)"/)?.[1] ?? "200";
+      const labels = this.seriesLabels.get(key);
+      if (!labels)
+        continue;
+      const { method, path, status } = labels;
       byStatus[status] = (byStatus[status] ?? 0) + count;
       const pathKey = `${method} ${path}`;
       const existing = pathCounts.get(pathKey);
@@ -59,33 +120,69 @@ class PrometheusRegistry {
       topPaths
     };
   }
+  getStorageStats() {
+    return {
+      series: this.seriesLabels.size,
+      histograms: this.httpRequestDurationMs.size,
+      bucketCounters: this.httpRequestDurationMs.size * HTTP_DURATION_BUCKETS_MS.length
+    };
+  }
   metricKey(labels) {
-    return `method="${labels.method}",path="${labels.path}",status="${labels.status}"`;
+    const normalized = {
+      method: /^(GET|HEAD|POST|PUT|PATCH|DELETE|CONNECT|OPTIONS|TRACE)$/.test(labels.method) ? labels.method : "OTHER",
+      path: labels.path.length <= 512 ? labels.path : "__overflow__",
+      status: /^[1-5][0-9]{2}$/.test(labels.status) ? labels.status : "000"
+    };
+    const escapeLabel = (value) => value.replaceAll("\\", "\\\\").replaceAll(`
+`, "\\n").replaceAll('"', "\\\"");
+    const encode = (value) => `method="${value.method}",path="${escapeLabel(value.path)}",status="${value.status}"`;
+    let key = encode(normalized);
+    if (!this.seriesLabels.has(key)) {
+      if (this.seriesLabels.size >= this.maxSeries) {
+        const overflow = { method: "OTHER", path: "__overflow__", status: "000" };
+        key = encode(overflow);
+        this.seriesLabels.set(key, overflow);
+      } else {
+        this.seriesLabels.set(key, normalized);
+      }
+    }
+    return key;
   }
 }
 var prometheusRegistry = new PrometheusRegistry;
 
-// ../../src/core/http/metricsMiddleware.ts
-function normalizeMetricPath(pathname) {
-  return pathname.replace(/\/\d+/g, "/:id").replace(/\/[0-9a-f-]{36}/gi, "/:id");
+// ../../src/core/http/requestMetaContext.ts
+init_asyncContextStore();
+var requestMetaContext = createAsyncContextStore("@getstrata/requestMetaContext");
+function runWithRequestMeta(meta, callback) {
+  return requestMetaContext.run(meta, callback);
+}
+function currentRequestMeta() {
+  return requestMetaContext.getStore() ?? {
+    ipAddress: null,
+    userAgent: null
+  };
 }
+
+// ../../src/core/http/metricsMiddleware.ts
 function createMetricsMiddleware() {
   return async (request, next) => {
     const startedAt = performance.now();
-    const response = await next();
-    const durationMs = performance.now() - startedAt;
-    const path = normalizeMetricPath(new URL(request.url).pathname);
-    const labels = {
-      method: request.method,
-      path,
-      status: String(response.status)
-    };
-    prometheusRegistry.incrementHttpRequest(labels);
-    prometheusRegistry.observeHttpDuration(labels, durationMs);
-    return response;
+    let response;
+    try {
+      response = await next();
+      return response;
+    } finally {
+      const labels = {
+        method: request.method,
+        path: currentRequestMeta().routeTemplate ?? "__unmatched__",
+        status: String(response?.status ?? 500)
+      };
+      prometheusRegistry.incrementHttpRequest(labels);
+      prometheusRegistry.observeHttpDuration(labels, performance.now() - startedAt);
+    }
   };
 }
 export {
-  createMetricsMiddleware,
-  normalizeMetricPath
+  createMetricsMiddleware
 };