@digilogiclabs/platform-core 1.0.0

package/dist/testing.mjs

@@ -0,0 +1,1743 @@
+// src/adapters/memory/MemoryDatabase.ts
+var MemoryDatabase = class {
+  tables = /* @__PURE__ */ new Map();
+  from(table) {
+    if (!this.tables.has(table)) {
+      this.tables.set(table, []);
+    }
+    return new MemoryQueryBuilder(this.tables, table);
+  }
+  async raw(sql, params) {
+    console.warn("MemoryDatabase.raw() is a stub implementation");
+    return { data: [] };
+  }
+  async transaction(fn) {
+    return fn(this);
+  }
+  async healthCheck() {
+    return true;
+  }
+  async close() {
+    this.tables.clear();
+  }
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.tables.clear();
+  }
+  /**
+   * Get table data (for testing)
+   */
+  getTable(tableName) {
+    return this.tables.get(tableName) ?? [];
+  }
+};
+var MemoryQueryBuilder = class {
+  tables;
+  tableName;
+  _select = ["*"];
+  _where = [];
+  _orderBy = null;
+  _limit = null;
+  _offset = 0;
+  _insertData = null;
+  _updateData = null;
+  _deleteFlag = false;
+  constructor(tables, tableName) {
+    this.tables = tables;
+    this.tableName = tableName;
+  }
+  select(columns) {
+    if (columns) {
+      this._select = Array.isArray(columns) ? columns : [columns];
+    }
+    return this;
+  }
+  insert(data) {
+    this._insertData = Array.isArray(data) ? data : [data];
+    return this;
+  }
+  update(data) {
+    this._updateData = data;
+    return this;
+  }
+  delete() {
+    this._deleteFlag = true;
+    return this;
+  }
+  where(column, operator, value) {
+    this._where.push({ column, operator, value });
+    return this;
+  }
+  whereIn(column, values) {
+    this._where.push({ column, operator: "in", value: values });
+    return this;
+  }
+  orderBy(column, direction = "asc") {
+    this._orderBy = { column, direction };
+    return this;
+  }
+  limit(count) {
+    this._limit = count;
+    return this;
+  }
+  offset(count) {
+    this._offset = count;
+    return this;
+  }
+  async single() {
+    const result = await this.execute();
+    return { data: result.data[0] || null };
+  }
+  async execute() {
+    const table = this.tables.get(this.tableName) || [];
+    if (this._insertData) {
+      const newItems = this._insertData.map((item, i) => ({
+        id: `mem_${Date.now()}_${i}`,
+        ...item,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      this.tables.set(this.tableName, [...table, ...newItems]);
+      return { data: newItems };
+    }
+    if (this._deleteFlag) {
+      const filtered = table.filter((item) => !this.matchesWhere(item));
+      const deleted = table.filter((item) => this.matchesWhere(item));
+      this.tables.set(this.tableName, filtered);
+      return { data: deleted, count: deleted.length };
+    }
+    if (this._updateData) {
+      const updated = [];
+      const newTable = table.map((item) => {
+        if (this.matchesWhere(item)) {
+          const updatedItem = { ...item, ...this._updateData, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+          updated.push(updatedItem);
+          return updatedItem;
+        }
+        return item;
+      });
+      this.tables.set(this.tableName, newTable);
+      return { data: updated, count: updated.length };
+    }
+    let result = table.filter((item) => this.matchesWhere(item));
+    if (this._orderBy) {
+      const { column, direction } = this._orderBy;
+      result.sort((a, b) => {
+        const aVal = a[column];
+        const bVal = b[column];
+        if (aVal === null || aVal === void 0) return direction === "asc" ? 1 : -1;
+        if (bVal === null || bVal === void 0) return direction === "asc" ? -1 : 1;
+        const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+        return direction === "asc" ? cmp : -cmp;
+      });
+    }
+    if (this._offset > 0 || this._limit !== null) {
+      const start = this._offset;
+      const end = this._limit !== null ? start + this._limit : void 0;
+      result = result.slice(start, end);
+    }
+    return { data: result, count: result.length };
+  }
+  matchesWhere(item) {
+    if (this._where.length === 0) return true;
+    return this._where.every(({ column, operator, value }) => {
+      const itemValue = item[column];
+      switch (operator) {
+        case "=":
+        case "==":
+          return itemValue === value;
+        case "!=":
+        case "<>":
+          return itemValue !== value;
+        case ">":
+          return itemValue > value;
+        case ">=":
+          return itemValue >= value;
+        case "<":
+          return itemValue < value;
+        case "<=":
+          return itemValue <= value;
+        case "in":
+          return Array.isArray(value) && value.includes(itemValue);
+        case "like":
+          return String(itemValue).includes(String(value).replace(/%/g, ""));
+        default:
+          return itemValue === value;
+      }
+    });
+  }
+};
+
+// src/adapters/memory/MemoryCache.ts
+var MemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  subscriptions = /* @__PURE__ */ new Map();
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = ttl ? Date.now() + ttl * 1e3 : null;
+    this.store.set(key, { value, expiresAt });
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async exists(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  async deletePattern(pattern) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    let count = 0;
+    for (const key of this.store.keys()) {
+      if (regex.test(key)) {
+        this.store.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async mget(keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  async mset(entries) {
+    await Promise.all(entries.map(({ key, value, ttl }) => this.set(key, value, ttl)));
+  }
+  async incr(key, by = 1) {
+    const current = await this.get(key) || 0;
+    const newValue = current + by;
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async publish(channel, message) {
+    const subscribers = this.subscriptions.get(channel);
+    if (subscribers) {
+      subscribers.forEach((callback) => callback(message));
+    }
+  }
+  async subscribe(channel, callback) {
+    if (!this.subscriptions.has(channel)) {
+      this.subscriptions.set(channel, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(channel).add(callback);
+    return () => {
+      this.subscriptions.get(channel)?.delete(callback);
+    };
+  }
+  async healthCheck() {
+    return true;
+  }
+  async close() {
+    this.store.clear();
+    this.subscriptions.clear();
+  }
+  /**
+   * Clear all cached data (for testing)
+   */
+  clear() {
+    this.store.clear();
+    this.subscriptions.clear();
+  }
+  /**
+   * Get number of cached items (for testing)
+   */
+  get size() {
+    return this.store.size;
+  }
+};
+
+// src/adapters/memory/MemoryStorage.ts
+var MemoryStorage = class {
+  files = /* @__PURE__ */ new Map();
+  async upload(key, data, options) {
+    this.files.set(key, { data: Buffer.from("mock"), contentType: options?.contentType });
+    return { url: "memory://" + key };
+  }
+  async download(key) {
+    return this.files.get(key)?.data || Buffer.from("");
+  }
+  async getSignedUrl(key) {
+    return "memory://" + key;
+  }
+  async delete(key) {
+    this.files.delete(key);
+  }
+  async deleteMany(keys) {
+    keys.forEach((k) => this.files.delete(k));
+  }
+  async list(prefix) {
+    return [];
+  }
+  async exists(key) {
+    return this.files.has(key);
+  }
+  async getMetadata(key) {
+    return null;
+  }
+  async healthCheck() {
+    return true;
+  }
+  /**
+   * Clear all files (for testing)
+   */
+  clear() {
+    this.files.clear();
+  }
+  /**
+   * Get number of stored files (for testing)
+   */
+  get size() {
+    return this.files.size;
+  }
+};
+
+// src/adapters/memory/MemoryEmail.ts
+var MemoryEmail = class {
+  sentEmails = [];
+  async send(message) {
+    this.sentEmails.push(message);
+    return { id: "mem_" + this.sentEmails.length, success: true };
+  }
+  async sendBatch(messages) {
+    return Promise.all(messages.map((m) => this.send(m)));
+  }
+  async healthCheck() {
+    return true;
+  }
+  // Test helpers
+  getSentEmails() {
+    return this.sentEmails;
+  }
+  /**
+   * Clear sent emails (for testing)
+   */
+  clear() {
+    this.sentEmails = [];
+  }
+  /**
+   * Get number of sent emails (for testing)
+   */
+  get size() {
+    return this.sentEmails.length;
+  }
+};
+
+// src/adapters/memory/MemoryQueue.ts
+var MemoryQueue = class {
+  jobs = [];
+  handlers = [];
+  async add(name, data, options) {
+    const job = { id: "job_" + this.jobs.length, name, data, attemptsMade: 0, progress: 0, timestamp: Date.now() };
+    this.jobs.push(job);
+    this.handlers.forEach((h) => h(job));
+    return job;
+  }
+  async addBulk(jobs) {
+    return Promise.all(jobs.map((j) => this.add(j.name, j.data, j.options)));
+  }
+  process(handler) {
+    this.handlers.push(handler);
+  }
+  async getJob(id) {
+    return this.jobs.find((j) => j.id === id) || null;
+  }
+  async removeJob(id) {
+    this.jobs = this.jobs.filter((j) => j.id !== id);
+  }
+  async pause() {
+  }
+  async resume() {
+  }
+  async getStats() {
+    return { waiting: 0, active: 0, completed: this.jobs.length, failed: 0, delayed: 0 };
+  }
+  async healthCheck() {
+    return true;
+  }
+  async close() {
+    this.jobs = [];
+  }
+  /**
+   * Clear all jobs (for testing)
+   */
+  clear() {
+    this.jobs = [];
+    this.handlers = [];
+  }
+  /**
+   * Get all jobs (for testing)
+   */
+  getJobs() {
+    return this.jobs;
+  }
+  /**
+   * Get pending jobs (for testing)
+   */
+  getPendingJobs() {
+    return this.jobs.filter((j) => j.progress < 100);
+  }
+  /**
+   * Get number of jobs (for testing)
+   */
+  get size() {
+    return this.jobs.length;
+  }
+};
+
+// src/adapters/console/ConsoleEmail.ts
+var ConsoleEmail = class {
+  sentEmails = [];
+  async send(message) {
+    const id = `console_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    console.log("\n" + "=".repeat(60));
+    console.log("\u{1F4E7} EMAIL SENT (Console Adapter)");
+    console.log("=".repeat(60));
+    console.log(`ID:      ${id}`);
+    console.log(`To:      ${this.formatAddresses(message.to)}`);
+    console.log(`From:    ${message.from ? this.formatAddress(message.from) : "(default)"}`);
+    console.log(`Subject: ${message.subject}`);
+    if (message.replyTo) {
+      console.log(`Reply-To: ${this.formatAddress(message.replyTo)}`);
+    }
+    if (message.tags && message.tags.length > 0) {
+      console.log(`Tags:    ${message.tags.join(", ")}`);
+    }
+    if (message.attachments && message.attachments.length > 0) {
+      console.log(`Attachments: ${message.attachments.map((a) => a.filename).join(", ")}`);
+    }
+    console.log("-".repeat(60));
+    if (message.text) {
+      console.log("TEXT BODY:");
+      console.log(message.text.slice(0, 500) + (message.text.length > 500 ? "\n...(truncated)" : ""));
+    }
+    if (message.html) {
+      console.log("HTML BODY: [HTML content - " + message.html.length + " chars]");
+    }
+    console.log("=".repeat(60) + "\n");
+    this.sentEmails.push(message);
+    return {
+      id,
+      success: true
+    };
+  }
+  async sendBatch(messages) {
+    const results = [];
+    for (const message of messages) {
+      results.push(await this.send(message));
+    }
+    return results;
+  }
+  async healthCheck() {
+    return true;
+  }
+  /**
+   * Get all sent emails (for testing)
+   */
+  getSentEmails() {
+    return [...this.sentEmails];
+  }
+  /**
+   * Clear sent emails (for testing)
+   */
+  clearSentEmails() {
+    this.sentEmails = [];
+  }
+  formatAddress(address) {
+    if (address.name) {
+      return `${address.name} <${address.email}>`;
+    }
+    return address.email;
+  }
+  formatAddresses(addresses) {
+    const list = Array.isArray(addresses) ? addresses : [addresses];
+    return list.map((addr) => this.formatAddress(addr)).join(", ");
+  }
+};
+
+// src/interfaces/ISecrets.ts
+var EnvSecrets = class {
+  prefix;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "";
+  }
+  getEnvKey(key) {
+    const normalizedKey = key.toUpperCase().replace(/[.-]/g, "_");
+    return this.prefix ? `${this.prefix}_${normalizedKey}` : normalizedKey;
+  }
+  async get(key, options) {
+    if (options?.cacheTtl) {
+      const cached = this.cache.get(key);
+      if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+      }
+    }
+    const envKey = this.getEnvKey(key);
+    const value = process.env[envKey] ?? null;
+    if (value && options?.cacheTtl) {
+      this.cache.set(key, {
+        value,
+        expiresAt: Date.now() + options.cacheTtl * 1e3
+      });
+    }
+    return value;
+  }
+  async getWithMetadata(key, options) {
+    const value = await this.get(key, options);
+    if (value === null) {
+      return null;
+    }
+    return {
+      key,
+      value,
+      metadata: {
+        // Environment variables don't have native metadata
+        createdAt: void 0,
+        updatedAt: void 0
+      }
+    };
+  }
+  async mget(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      result.set(key, await this.get(key));
+    }
+    return result;
+  }
+  async set(key, value, _options) {
+    const envKey = this.getEnvKey(key);
+    process.env[envKey] = value;
+    this.cache.delete(key);
+  }
+  async delete(key) {
+    const envKey = this.getEnvKey(key);
+    delete process.env[envKey];
+    this.cache.delete(key);
+  }
+  async exists(key) {
+    const envKey = this.getEnvKey(key);
+    return process.env[envKey] !== void 0;
+  }
+  async list(prefix) {
+    const keys = [];
+    const envPrefix = this.prefix ? `${this.prefix}_` : "";
+    const searchPrefix = prefix ? `${envPrefix}${prefix.toUpperCase().replace(/[.-]/g, "_")}` : envPrefix;
+    for (const key of Object.keys(process.env)) {
+      if (key.startsWith(searchPrefix || "")) {
+        const normalizedKey = key.slice(envPrefix.length).toLowerCase().replace(/_/g, "-");
+        keys.push(normalizedKey);
+      }
+    }
+    return keys;
+  }
+  async rotate(key, options) {
+    const previousValue = await this.get(key);
+    const newValue = options?.rotationFn ? await options.rotationFn() : this.generateSecureValue();
+    await this.set(key, newValue);
+    return {
+      newValue,
+      previousValue: previousValue ?? void 0,
+      newVersion: "current",
+      previousVersion: previousValue ? "previous" : void 0
+    };
+  }
+  async getVersions(_key) {
+    return [];
+  }
+  async healthCheck() {
+    return true;
+  }
+  generateSecureValue(length = 32) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+    let result = "";
+    const randomValues = new Uint32Array(length);
+    crypto.getRandomValues(randomValues);
+    for (let i = 0; i < length; i++) {
+      result += chars[randomValues[i] % chars.length];
+    }
+    return result;
+  }
+  /**
+   * Clear the internal cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+var MemorySecrets = class {
+  secrets = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  async get(key, _options) {
+    const secret = this.secrets.get(key);
+    if (!secret) {
+      return null;
+    }
+    if (secret.metadata?.expiresAt && secret.metadata.expiresAt < /* @__PURE__ */ new Date()) {
+      await this.delete(key);
+      return null;
+    }
+    return secret.value;
+  }
+  async getWithMetadata(key, options) {
+    const value = await this.get(key, options);
+    if (value === null) {
+      return null;
+    }
+    return this.secrets.get(key) ?? null;
+  }
+  async mget(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      result.set(key, await this.get(key));
+    }
+    return result;
+  }
+  async set(key, value, options) {
+    const now = /* @__PURE__ */ new Date();
+    const version = `v${Date.now()}`;
+    const currentSecret = this.secrets.get(key);
+    if (currentSecret?.metadata) {
+      const history = this.versions.get(key) ?? [];
+      history.push(currentSecret.metadata);
+      this.versions.set(key, history);
+    }
+    this.secrets.set(key, {
+      key,
+      value,
+      metadata: {
+        version,
+        createdAt: currentSecret?.metadata?.createdAt ?? now,
+        updatedAt: now,
+        expiresAt: options?.expiresAt,
+        tags: options?.tags
+      }
+    });
+  }
+  async delete(key) {
+    this.secrets.delete(key);
+    this.versions.delete(key);
+  }
+  async exists(key) {
+    return this.secrets.has(key);
+  }
+  async list(prefix) {
+    const keys = [];
+    for (const key of this.secrets.keys()) {
+      if (!prefix || key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  async rotate(key, options) {
+    const currentSecret = this.secrets.get(key);
+    const previousValue = currentSecret?.value;
+    const previousVersion = currentSecret?.metadata?.version;
+    const newValue = options?.rotationFn ? await options.rotationFn() : this.generateSecureValue();
+    await this.set(key, newValue);
+    const newVersion = this.secrets.get(key)?.metadata?.version ?? "unknown";
+    return {
+      newValue,
+      previousValue,
+      newVersion,
+      previousVersion
+    };
+  }
+  async getVersions(key) {
+    const current = this.secrets.get(key)?.metadata;
+    const history = this.versions.get(key) ?? [];
+    if (current) {
+      return [...history, current];
+    }
+    return history;
+  }
+  async healthCheck() {
+    return true;
+  }
+  generateSecureValue(length = 32) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+  }
+  /**
+   * Clear all secrets (for testing)
+   */
+  clear() {
+    this.secrets.clear();
+    this.versions.clear();
+  }
+  /**
+   * Get count of secrets (for testing)
+   */
+  get size() {
+    return this.secrets.size;
+  }
+};
+
+// src/config.ts
+import { z } from "zod";
+var DatabaseProviderSchema = z.enum(["memory", "postgres", "supabase"]);
+var CacheProviderSchema = z.enum(["memory", "redis", "upstash"]);
+var StorageProviderSchema = z.enum(["memory", "s3", "minio", "r2", "supabase"]);
+var EmailProviderSchema = z.enum(["memory", "console", "smtp", "resend"]);
+var QueueProviderSchema = z.enum(["memory", "bullmq"]);
+var TracingProviderSchema = z.enum(["noop", "memory", "otlp"]);
+var LogLevelSchema = z.enum(["debug", "info", "warn", "error"]);
+var DatabaseConfigSchema = z.object({
+  provider: DatabaseProviderSchema.default("memory"),
+  url: z.string().optional().describe("PostgreSQL connection URL"),
+  connectionString: z.string().optional().describe("PostgreSQL connection string (alias for url)"),
+  supabaseUrl: z.string().url().optional().describe("Supabase project URL"),
+  supabaseAnonKey: z.string().optional().describe("Supabase anonymous key"),
+  supabaseServiceRoleKey: z.string().optional().describe("Supabase service role key"),
+  poolSize: z.number().int().min(1).max(100).default(10).describe("Connection pool size"),
+  connectionTimeout: z.number().int().min(1e3).max(6e4).default(5e3).describe("Connection timeout in ms"),
+  ssl: z.union([z.boolean(), z.object({ rejectUnauthorized: z.boolean().optional() })]).optional().describe("SSL configuration")
+}).refine(
+  (data) => {
+    if (data.provider === "supabase") {
+      return data.supabaseUrl && data.supabaseAnonKey;
+    }
+    if (data.provider === "postgres") {
+      return data.url || data.connectionString;
+    }
+    return true;
+  },
+  {
+    message: "Supabase requires supabaseUrl and supabaseAnonKey; PostgreSQL requires url or connectionString"
+  }
+);
+var CacheConfigSchema = z.object({
+  provider: CacheProviderSchema.default("memory"),
+  url: z.string().url().optional().describe("Redis connection URL"),
+  upstashUrl: z.string().url().optional().describe("Upstash REST URL"),
+  upstashToken: z.string().optional().describe("Upstash REST token"),
+  defaultTTL: z.number().int().min(0).default(3600).describe("Default TTL in seconds"),
+  keyPrefix: z.string().default("").describe("Prefix for all cache keys"),
+  maxRetries: z.number().int().min(0).max(10).default(3).describe("Max retries for cache operations")
+}).refine(
+  (data) => {
+    if (data.provider === "upstash") {
+      return data.upstashUrl && data.upstashToken;
+    }
+    if (data.provider === "redis") {
+      return data.url;
+    }
+    return true;
+  },
+  {
+    message: "Upstash requires upstashUrl and upstashToken; Redis requires url"
+  }
+);
+var StorageConfigSchema = z.object({
+  provider: StorageProviderSchema.default("memory"),
+  endpoint: z.string().url().optional().describe("S3-compatible endpoint URL"),
+  region: z.string().default("us-east-1").describe("AWS region"),
+  accessKey: z.string().optional().describe("AWS access key ID"),
+  secretKey: z.string().optional().describe("AWS secret access key"),
+  bucket: z.string().optional().describe("S3 bucket name"),
+  publicUrl: z.string().url().optional().describe("Public URL for accessing files"),
+  forcePathStyle: z.boolean().default(false).describe("Use path-style URLs (required for MinIO)"),
+  signedUrlExpiry: z.number().int().min(60).max(604800).default(3600).describe("Signed URL expiry in seconds")
+}).refine(
+  (data) => {
+    if (["s3", "minio", "r2"].includes(data.provider)) {
+      return data.accessKey && data.secretKey && data.bucket;
+    }
+    return true;
+  },
+  {
+    message: "S3/MinIO/R2 requires accessKey, secretKey, and bucket"
+  }
+);
+var EmailConfigSchema = z.object({
+  provider: EmailProviderSchema.default("memory"),
+  host: z.string().optional().describe("SMTP host"),
+  port: z.number().int().min(1).max(65535).optional().describe("SMTP port"),
+  secure: z.boolean().default(false).describe("Use TLS for SMTP"),
+  username: z.string().optional().describe("SMTP username"),
+  password: z.string().optional().describe("SMTP password"),
+  apiKey: z.string().optional().describe("Resend API key"),
+  from: z.string().email().or(z.string().regex(/^.+\s<.+@.+>$/)).optional().describe("Default from address"),
+  replyTo: z.string().email().optional().describe("Default reply-to address"),
+  rateLimitPerSecond: z.number().int().min(1).max(100).default(10).describe("Max emails per second")
+}).refine(
+  (data) => {
+    if (data.provider === "smtp") {
+      return data.host && data.port;
+    }
+    if (data.provider === "resend") {
+      return data.apiKey;
+    }
+    return true;
+  },
+  {
+    message: "SMTP requires host and port; Resend requires apiKey"
+  }
+);
+var QueueConfigSchema = z.object({
+  provider: QueueProviderSchema.default("memory"),
+  redisUrl: z.string().url().optional().describe("Redis connection URL for BullMQ"),
+  queueName: z.string().default("platform-jobs").describe("Default queue name"),
+  concurrency: z.number().int().min(1).max(100).default(5).describe("Worker concurrency"),
+  maxRetries: z.number().int().min(0).max(10).default(3).describe("Max job retries"),
+  retryDelay: z.number().int().min(0).default(1e3).describe("Retry delay in ms"),
+  removeOnComplete: z.boolean().default(true).describe("Remove completed jobs"),
+  removeOnFail: z.boolean().default(false).describe("Remove failed jobs")
+}).refine(
+  (data) => {
+    if (data.provider === "bullmq") {
+      return data.redisUrl;
+    }
+    return true;
+  },
+  {
+    message: "BullMQ requires redisUrl"
+  }
+);
+var RetryConfigSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable retry for failed operations"),
+  maxAttempts: z.number().int().min(1).max(10).default(3).describe("Maximum retry attempts"),
+  baseDelay: z.number().int().min(0).max(1e4).default(100).describe("Base delay in ms"),
+  maxDelay: z.number().int().min(0).max(6e4).default(5e3).describe("Maximum delay in ms"),
+  backoffMultiplier: z.number().min(1).max(5).default(2).describe("Exponential backoff multiplier"),
+  jitter: z.boolean().default(true).describe("Add jitter to retry delays")
+});
+var CircuitBreakerConfigSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable circuit breaker"),
+  failureThreshold: z.number().int().min(1).max(100).default(5).describe("Failures before opening circuit"),
+  resetTimeout: z.number().int().min(1e3).max(3e5).default(3e4).describe("Reset timeout in ms"),
+  halfOpenRequests: z.number().int().min(1).max(10).default(3).describe("Requests allowed in half-open state"),
+  monitorInterval: z.number().int().min(1e3).max(6e4).default(1e4).describe("Health monitor interval in ms")
+});
+var TimeoutConfigSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable operation timeouts"),
+  default: z.number().int().min(100).max(3e5).default(3e4).describe("Default timeout in ms"),
+  database: z.number().int().min(100).max(3e5).default(1e4).describe("Database operation timeout"),
+  cache: z.number().int().min(100).max(6e4).default(5e3).describe("Cache operation timeout"),
+  storage: z.number().int().min(100).max(6e5).default(6e4).describe("Storage operation timeout"),
+  email: z.number().int().min(100).max(12e4).default(3e4).describe("Email operation timeout"),
+  queue: z.number().int().min(100).max(6e4).default(1e4).describe("Queue operation timeout")
+});
+var BulkheadConfigSchema = z.object({
+  enabled: z.boolean().default(false).describe("Enable bulkhead isolation"),
+  maxConcurrent: z.number().int().min(1).max(1e3).default(10).describe("Maximum concurrent operations"),
+  maxQueued: z.number().int().min(0).max(1e4).default(100).describe("Maximum queued operations"),
+  timeout: z.number().int().min(0).max(3e5).default(3e4).describe("Queue timeout in ms")
+});
+var ResilienceConfigSchema = z.object({
+  retry: RetryConfigSchema.default({}),
+  circuitBreaker: CircuitBreakerConfigSchema.default({}),
+  timeout: TimeoutConfigSchema.default({}),
+  bulkhead: BulkheadConfigSchema.default({})
+});
+var LoggingConfigSchema = z.object({
+  level: LogLevelSchema.default("info").describe("Minimum log level"),
+  format: z.enum(["json", "pretty"]).default("json").describe("Log output format"),
+  includeTimestamp: z.boolean().default(true).describe("Include timestamp in logs"),
+  includeCorrelationId: z.boolean().default(true).describe("Include correlation ID in logs"),
+  redactKeys: z.array(z.string()).default(["password", "token", "secret", "apiKey", "authorization"]).describe("Keys to redact from logs")
+});
+var MetricsConfigSchema = z.object({
+  enabled: z.boolean().default(false).describe("Enable metrics collection"),
+  prefix: z.string().default("platform").describe("Metric name prefix"),
+  defaultTags: z.record(z.string()).default({}).describe("Default tags for all metrics"),
+  flushInterval: z.number().int().min(1e3).max(6e4).default(1e4).describe("Flush interval in ms"),
+  histogramBuckets: z.array(z.number()).default([5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4]).describe("Histogram bucket boundaries in ms")
+});
+var TracingConfigSchema = z.object({
+  enabled: z.boolean().default(false).describe("Enable distributed tracing"),
+  provider: TracingProviderSchema.default("noop").describe("Tracing provider"),
+  serviceName: z.string().optional().describe("Service name for traces"),
+  serviceVersion: z.string().optional().describe("Service version"),
+  environment: z.string().optional().describe("Environment (dev, staging, production)"),
+  sampleRate: z.number().min(0).max(1).default(1).describe("Trace sampling rate"),
+  propagateContext: z.boolean().default(true).describe("Propagate trace context to downstream services"),
+  endpoint: z.string().url().optional().describe("OTLP exporter endpoint"),
+  exporterType: z.enum(["otlp-http", "otlp-grpc", "console"]).default("otlp-http").describe("Exporter type")
+});
+var ObservabilityConfigSchema = z.object({
+  logging: LoggingConfigSchema.default({}),
+  metrics: MetricsConfigSchema.default({}),
+  tracing: TracingConfigSchema.default({})
+});
+var MiddlewareConfigSchema = z.object({
+  enabled: z.boolean().default(true).describe("Enable middleware chain"),
+  logging: z.boolean().default(true).describe("Enable logging middleware"),
+  metrics: z.boolean().default(false).describe("Enable metrics middleware"),
+  slowQuery: z.object({
+    enabled: z.boolean().default(true),
+    thresholdMs: z.number().int().min(1).default(1e3)
+  }).default({}),
+  cache: z.object({
+    enabled: z.boolean().default(false),
+    defaultTTL: z.number().int().min(0).default(300)
+  }).default({})
+});
+var PlatformConfigSchema = z.object({
+  // Service configurations
+  database: DatabaseConfigSchema.default({ provider: "memory" }),
+  cache: CacheConfigSchema.default({ provider: "memory" }),
+  storage: StorageConfigSchema.default({ provider: "memory" }),
+  email: EmailConfigSchema.default({ provider: "memory" }),
+  queue: QueueConfigSchema.default({ provider: "memory" }),
+  // Resilience configuration
+  resilience: ResilienceConfigSchema.default({}),
+  // Observability configuration
+  observability: ObservabilityConfigSchema.default({}),
+  // Middleware configuration
+  middleware: MiddlewareConfigSchema.default({})
+});
+function loadConfig() {
+  return PlatformConfigSchema.parse({
+    database: {
+      provider: process.env.PLATFORM_DB_PROVIDER || process.env.DATABASE_PROVIDER || "memory",
+      url: process.env.DATABASE_URL,
+      supabaseUrl: process.env.SUPABASE_URL,
+      supabaseAnonKey: process.env.SUPABASE_ANON_KEY,
+      supabaseServiceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
+      poolSize: process.env.DATABASE_POOL_SIZE ? parseInt(process.env.DATABASE_POOL_SIZE) : void 0,
+      connectionTimeout: process.env.DATABASE_TIMEOUT ? parseInt(process.env.DATABASE_TIMEOUT) : void 0
+    },
+    cache: {
+      provider: process.env.PLATFORM_CACHE_PROVIDER || process.env.CACHE_PROVIDER || "memory",
+      url: process.env.REDIS_URL,
+      upstashUrl: process.env.UPSTASH_REDIS_REST_URL,
+      upstashToken: process.env.UPSTASH_REDIS_REST_TOKEN,
+      defaultTTL: process.env.CACHE_DEFAULT_TTL ? parseInt(process.env.CACHE_DEFAULT_TTL) : void 0,
+      keyPrefix: process.env.CACHE_KEY_PREFIX
+    },
+    storage: {
+      provider: process.env.PLATFORM_STORAGE_PROVIDER || process.env.STORAGE_PROVIDER || "memory",
+      endpoint: process.env.S3_ENDPOINT,
+      region: process.env.S3_REGION || process.env.AWS_REGION || "us-east-1",
+      accessKey: process.env.S3_ACCESS_KEY_ID || process.env.AWS_ACCESS_KEY_ID,
+      secretKey: process.env.S3_SECRET_ACCESS_KEY || process.env.AWS_SECRET_ACCESS_KEY,
+      bucket: process.env.S3_BUCKET,
+      publicUrl: process.env.S3_PUBLIC_URL,
+      forcePathStyle: process.env.S3_FORCE_PATH_STYLE === "true",
+      signedUrlExpiry: process.env.S3_SIGNED_URL_EXPIRY ? parseInt(process.env.S3_SIGNED_URL_EXPIRY) : void 0
+    },
+    email: {
+      provider: process.env.PLATFORM_EMAIL_PROVIDER || process.env.EMAIL_PROVIDER || "memory",
+      host: process.env.SMTP_HOST,
+      port: process.env.SMTP_PORT ? parseInt(process.env.SMTP_PORT) : void 0,
+      secure: process.env.SMTP_SECURE === "true",
+      username: process.env.SMTP_USERNAME,
+      password: process.env.SMTP_PASSWORD,
+      apiKey: process.env.RESEND_API_KEY,
+      from: process.env.EMAIL_FROM,
+      replyTo: process.env.EMAIL_REPLY_TO
+    },
+    queue: {
+      provider: process.env.PLATFORM_QUEUE_PROVIDER || process.env.QUEUE_PROVIDER || "memory",
+      redisUrl: process.env.REDIS_URL,
+      queueName: process.env.QUEUE_NAME,
+      concurrency: process.env.QUEUE_CONCURRENCY ? parseInt(process.env.QUEUE_CONCURRENCY) : void 0,
+      maxRetries: process.env.QUEUE_MAX_RETRIES ? parseInt(process.env.QUEUE_MAX_RETRIES) : void 0
+    },
+    resilience: {
+      retry: {
+        enabled: process.env.RESILIENCE_RETRY_ENABLED !== "false",
+        maxAttempts: process.env.RESILIENCE_RETRY_MAX_ATTEMPTS ? parseInt(process.env.RESILIENCE_RETRY_MAX_ATTEMPTS) : void 0,
+        baseDelay: process.env.RESILIENCE_RETRY_BASE_DELAY ? parseInt(process.env.RESILIENCE_RETRY_BASE_DELAY) : void 0,
+        maxDelay: process.env.RESILIENCE_RETRY_MAX_DELAY ? parseInt(process.env.RESILIENCE_RETRY_MAX_DELAY) : void 0
+      },
+      circuitBreaker: {
+        enabled: process.env.RESILIENCE_CIRCUIT_BREAKER_ENABLED !== "false",
+        failureThreshold: process.env.RESILIENCE_CIRCUIT_BREAKER_THRESHOLD ? parseInt(process.env.RESILIENCE_CIRCUIT_BREAKER_THRESHOLD) : void 0,
+        resetTimeout: process.env.RESILIENCE_CIRCUIT_BREAKER_RESET_TIMEOUT ? parseInt(process.env.RESILIENCE_CIRCUIT_BREAKER_RESET_TIMEOUT) : void 0
+      },
+      timeout: {
+        enabled: process.env.RESILIENCE_TIMEOUT_ENABLED !== "false",
+        default: process.env.RESILIENCE_TIMEOUT_DEFAULT ? parseInt(process.env.RESILIENCE_TIMEOUT_DEFAULT) : void 0
+      }
+    },
+    observability: {
+      logging: {
+        level: process.env.LOG_LEVEL || "info",
+        format: process.env.LOG_FORMAT || "json"
+      },
+      metrics: {
+        enabled: process.env.METRICS_ENABLED === "true",
+        prefix: process.env.METRICS_PREFIX
+      },
+      tracing: {
+        enabled: process.env.TRACING_ENABLED === "true",
+        provider: process.env.TRACING_PROVIDER || "noop",
+        serviceName: process.env.SERVICE_NAME || process.env.OTEL_SERVICE_NAME,
+        serviceVersion: process.env.SERVICE_VERSION,
+        environment: process.env.NODE_ENV,
+        sampleRate: process.env.TRACING_SAMPLE_RATE ? parseFloat(process.env.TRACING_SAMPLE_RATE) : void 0,
+        endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || process.env.TRACING_ENDPOINT,
+        exporterType: process.env.OTEL_EXPORTER_TYPE || "otlp-http"
+      }
+    },
+    middleware: {
+      enabled: process.env.MIDDLEWARE_ENABLED !== "false",
+      logging: process.env.MIDDLEWARE_LOGGING !== "false",
+      metrics: process.env.MIDDLEWARE_METRICS === "true",
+      slowQuery: {
+        enabled: process.env.MIDDLEWARE_SLOW_QUERY !== "false",
+        thresholdMs: process.env.MIDDLEWARE_SLOW_QUERY_THRESHOLD ? parseInt(process.env.MIDDLEWARE_SLOW_QUERY_THRESHOLD) : void 0
+      }
+    }
+  });
+}
+
+// src/interfaces/ITracing.ts
+var MemorySpan = class {
+  name;
+  context;
+  isRecording = true;
+  _attributes = {};
+  _events = [];
+  _status = { code: "unset" };
+  _endTime;
+  _startTime;
+  constructor(name, traceId, parentSpanId) {
+    this.name = name;
+    this._startTime = Date.now();
+    this.context = {
+      traceId,
+      spanId: this.generateSpanId(),
+      traceFlags: 1
+    };
+  }
+  generateSpanId() {
+    return Math.random().toString(16).substring(2, 18).padStart(16, "0");
+  }
+  setAttribute(key, value) {
+    this._attributes[key] = value;
+    return this;
+  }
+  setAttributes(attributes) {
+    Object.assign(this._attributes, attributes);
+    return this;
+  }
+  addEvent(name, attributes) {
+    this._events.push({ name, timestamp: Date.now(), attributes });
+    return this;
+  }
+  setStatus(status) {
+    this._status = status;
+    return this;
+  }
+  recordException(exception, attributes) {
+    this.addEvent("exception", {
+      "exception.type": exception.name,
+      "exception.message": exception.message,
+      "exception.stacktrace": exception.stack || "",
+      ...attributes
+    });
+    this.setStatus({ code: "error", message: exception.message });
+    return this;
+  }
+  updateName(name) {
+    this.name = name;
+    return this;
+  }
+  end(endTime) {
+    this._endTime = endTime ?? Date.now();
+  }
+  // Testing helpers
+  getAttributes() {
+    return { ...this._attributes };
+  }
+  getEvents() {
+    return [...this._events];
+  }
+  getStatus() {
+    return { ...this._status };
+  }
+  getDuration() {
+    return this._endTime ? this._endTime - this._startTime : void 0;
+  }
+  isEnded() {
+    return this._endTime !== void 0;
+  }
+};
+var MemoryTracing = class {
+  spans = [];
+  currentSpan;
+  traceId;
+  constructor() {
+    this.traceId = this.generateTraceId();
+  }
+  generateTraceId() {
+    return Math.random().toString(16).substring(2, 34).padStart(32, "0");
+  }
+  startSpan(name, options) {
+    const span = new MemorySpan(name, this.traceId, this.currentSpan?.context.spanId);
+    if (options?.attributes) {
+      span.setAttributes(options.attributes);
+    }
+    this.spans.push(span);
+    this.currentSpan = span;
+    return span;
+  }
+  getCurrentSpan() {
+    return this.currentSpan;
+  }
+  withSpan(name, fn, options) {
+    const span = this.startSpan(name, options);
+    try {
+      const result = fn(span);
+      span.setStatus({ code: "ok" });
+      return result;
+    } catch (error) {
+      span.recordException(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  async withSpanAsync(name, fn, options) {
+    const span = this.startSpan(name, options);
+    try {
+      const result = await fn(span);
+      span.setStatus({ code: "ok" });
+      return result;
+    } catch (error) {
+      span.recordException(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+  instrument(name, fn, options) {
+    return (...args) => this.withSpan(name, () => fn(...args), options);
+  }
+  instrumentAsync(name, fn, options) {
+    return (...args) => this.withSpanAsync(name, () => fn(...args), options);
+  }
+  extractContext(headers) {
+    const traceparent = headers["traceparent"];
+    if (!traceparent || typeof traceparent !== "string") return void 0;
+    const parts = traceparent.split("-");
+    if (parts.length !== 4) return void 0;
+    return {
+      traceId: parts[1],
+      spanId: parts[2],
+      traceFlags: parseInt(parts[3], 16)
+    };
+  }
+  injectContext(headers) {
+    if (this.currentSpan) {
+      const ctx = this.currentSpan.context;
+      headers["traceparent"] = `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags.toString(16).padStart(2, "0")}`;
+    }
+  }
+  async healthCheck() {
+    return true;
+  }
+  async flush() {
+  }
+  async close() {
+    this.spans = [];
+    this.currentSpan = void 0;
+  }
+  // Testing helpers
+  getSpans() {
+    return [...this.spans];
+  }
+  getCompletedSpans() {
+    return this.spans.filter((s) => s.isEnded());
+  }
+  clear() {
+    this.spans = [];
+    this.currentSpan = void 0;
+    this.traceId = this.generateTraceId();
+  }
+};
+var NoopSpan = class {
+  name = "";
+  context = { traceId: "", spanId: "", traceFlags: 0 };
+  isRecording = false;
+  setAttribute() {
+    return this;
+  }
+  setAttributes() {
+    return this;
+  }
+  addEvent() {
+    return this;
+  }
+  setStatus() {
+    return this;
+  }
+  recordException() {
+    return this;
+  }
+  updateName() {
+    return this;
+  }
+  end() {
+  }
+};
+var NoopTracing = class {
+  noopSpan = new NoopSpan();
+  startSpan() {
+    return this.noopSpan;
+  }
+  getCurrentSpan() {
+    return void 0;
+  }
+  withSpan(_name, fn) {
+    return fn(this.noopSpan);
+  }
+  async withSpanAsync(_name, fn) {
+    return fn(this.noopSpan);
+  }
+  instrument(_name, fn) {
+    return fn;
+  }
+  instrumentAsync(_name, fn) {
+    return fn;
+  }
+  extractContext() {
+    return void 0;
+  }
+  injectContext() {
+  }
+  async healthCheck() {
+    return true;
+  }
+  async flush() {
+  }
+  async close() {
+  }
+};
+
+// src/interfaces/ILogger.ts
+var ConsoleLogger = class _ConsoleLogger {
+  context;
+  level;
+  static levelPriority = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  constructor(config = {}) {
+    this.context = {
+      service: config.service,
+      environment: config.environment
+    };
+    this.level = config.level || "info";
+  }
+  shouldLog(level) {
+    return _ConsoleLogger.levelPriority[level] >= _ConsoleLogger.levelPriority[this.level];
+  }
+  log(level, message, meta) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      meta,
+      context: this.context
+    };
+    const prefix = `[${entry.timestamp.toISOString()}] [${level.toUpperCase()}]`;
+    const contextStr = Object.keys(this.context).length > 0 ? ` [${Object.entries(this.context).map(([k, v]) => `${k}=${v}`).join(" ")}]` : "";
+    switch (level) {
+      case "debug":
+        console.debug(`${prefix}${contextStr} ${message}`, meta || "");
+        break;
+      case "info":
+        console.info(`${prefix}${contextStr} ${message}`, meta || "");
+        break;
+      case "warn":
+        console.warn(`${prefix}${contextStr} ${message}`, meta || "");
+        break;
+      case "error":
+        console.error(`${prefix}${contextStr} ${message}`, meta || "");
+        if (meta?.error) {
+          console.error(meta.error);
+        }
+        break;
+    }
+  }
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+  child(context) {
+    const childLogger = new _ConsoleLogger({ level: this.level });
+    childLogger.context = { ...this.context, ...context };
+    return childLogger;
+  }
+};
+var NoopLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  child() {
+    return this;
+  }
+};
+
+// src/interfaces/IMetrics.ts
+var MemoryMetrics = class {
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  timings = /* @__PURE__ */ new Map();
+  sets = /* @__PURE__ */ new Map();
+  increment(name, value = 1, tags = {}) {
+    const key = this.createKey(name, tags);
+    const existing = this.counters.get(key);
+    if (existing && existing[0]) {
+      existing[0].value += value;
+    } else {
+      this.counters.set(key, [{ value, tags }]);
+    }
+  }
+  decrement(name, value = 1, tags = {}) {
+    this.increment(name, -value, tags);
+  }
+  gauge(name, value, tags = {}) {
+    const key = this.createKey(name, tags);
+    this.gauges.set(key, { value, tags, timestamp: Date.now() });
+  }
+  histogram(name, value, tags = {}) {
+    const key = this.createKey(name, tags);
+    const existing = this.histograms.get(key);
+    if (existing && existing[0]) {
+      existing[0].values.push(value);
+    } else {
+      this.histograms.set(key, [{ values: [value], tags }]);
+    }
+  }
+  timing(name, value, tags = {}) {
+    const key = this.createKey(name, tags);
+    const existing = this.timings.get(key);
+    if (existing && existing[0]) {
+      existing[0].values.push(value);
+    } else {
+      this.timings.set(key, [{ values: [value], tags }]);
+    }
+  }
+  startTimer(name, tags = {}) {
+    const start = Date.now();
+    return () => {
+      const duration = Date.now() - start;
+      this.timing(name, duration, tags);
+    };
+  }
+  distribution(name, value, tags = {}) {
+    this.histogram(name, value, tags);
+  }
+  set(name, value, tags = {}) {
+    const key = this.createKey(name, tags);
+    let existing = this.sets.get(key);
+    if (!existing) {
+      existing = /* @__PURE__ */ new Set();
+      this.sets.set(key, existing);
+    }
+    existing.add(value);
+  }
+  async flush() {
+  }
+  async close() {
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // Test helpers
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get counter value
+   */
+  getCounter(name, tags = {}) {
+    const key = this.createKey(name, tags);
+    const data = this.counters.get(key);
+    return data?.[0]?.value ?? 0;
+  }
+  /**
+   * Get gauge value
+   */
+  getGauge(name, tags = {}) {
+    const key = this.createKey(name, tags);
+    return this.gauges.get(key)?.value;
+  }
+  /**
+   * Get histogram values
+   */
+  getHistogram(name, tags = {}) {
+    const key = this.createKey(name, tags);
+    return this.histograms.get(key)?.[0]?.values ?? [];
+  }
+  /**
+   * Get timing values
+   */
+  getTiming(name, tags = {}) {
+    const key = this.createKey(name, tags);
+    return this.timings.get(key)?.[0]?.values ?? [];
+  }
+  /**
+   * Get set size
+   */
+  getSetSize(name, tags = {}) {
+    const key = this.createKey(name, tags);
+    return this.sets.get(key)?.size ?? 0;
+  }
+  /**
+   * Get all metrics as a summary
+   */
+  getSummary() {
+    const summary = {
+      counters: {},
+      gauges: {},
+      histograms: {},
+      timings: {},
+      sets: {}
+    };
+    for (const [key, data] of this.counters) {
+      const first = data[0];
+      if (first) {
+        summary.counters[key] = first.value;
+      }
+    }
+    for (const [key, data] of this.gauges) {
+      summary.gauges[key] = data.value;
+    }
+    for (const [key, data] of this.histograms) {
+      const first = data[0];
+      if (first) {
+        const values = first.values;
+        summary.histograms[key] = {
+          count: values.length,
+          sum: values.reduce((a, b) => a + b, 0),
+          min: Math.min(...values),
+          max: Math.max(...values),
+          avg: values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0
+        };
+      }
+    }
+    for (const [key, data] of this.timings) {
+      const first = data[0];
+      if (first) {
+        const values = first.values;
+        summary.timings[key] = {
+          count: values.length,
+          sum: values.reduce((a, b) => a + b, 0),
+          min: Math.min(...values),
+          max: Math.max(...values),
+          avg: values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0,
+          p50: this.percentile(values, 50),
+          p95: this.percentile(values, 95),
+          p99: this.percentile(values, 99)
+        };
+      }
+    }
+    for (const [key, data] of this.sets) {
+      summary.sets[key] = data.size;
+    }
+    return summary;
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+    this.timings.clear();
+    this.sets.clear();
+  }
+  createKey(name, tags) {
+    const tagStr = Object.entries(tags).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join(",");
+    return tagStr ? `${name}|${tagStr}` : name;
+  }
+  percentile(values, p) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(p / 100 * sorted.length) - 1;
+    const safeIndex = Math.max(0, index);
+    return sorted[safeIndex] ?? 0;
+  }
+};
+var NoopMetrics = class {
+  increment() {
+  }
+  decrement() {
+  }
+  gauge() {
+  }
+  histogram() {
+  }
+  timing() {
+  }
+  startTimer() {
+    return () => {
+    };
+  }
+  distribution() {
+  }
+  set() {
+  }
+  async flush() {
+  }
+  async close() {
+  }
+};
+
+// src/factory.ts
+function createLogger(config) {
+  if (!config.observability.logging) {
+    return new NoopLogger();
+  }
+  return new ConsoleLogger({
+    level: config.observability.logging.level,
+    service: config.observability.tracing.serviceName,
+    environment: config.observability.tracing.environment
+  });
+}
+function createMetrics(config) {
+  if (!config.observability.metrics.enabled) {
+    return new NoopMetrics();
+  }
+  return new MemoryMetrics();
+}
+function createPlatform(config) {
+  const finalConfig = config ? deepMerge(loadConfig(), config) : loadConfig();
+  const hasProductionAdapters = finalConfig.database.provider !== "memory" || finalConfig.cache.provider !== "memory" || finalConfig.storage.provider !== "memory" || finalConfig.email.provider !== "memory" && finalConfig.email.provider !== "console" || finalConfig.observability.tracing.provider === "otlp";
+  if (hasProductionAdapters) {
+    console.warn(
+      "createPlatform() is synchronous and cannot initialize production adapters. Use createPlatformAsync() for production adapters, or use memory/console adapters."
+    );
+  }
+  const db = new MemoryDatabase();
+  const cache = new MemoryCache();
+  const storage = new MemoryStorage();
+  const email = finalConfig.email.provider === "console" ? new ConsoleEmail() : new MemoryEmail();
+  const queue = new MemoryQueue();
+  const logger = createLogger(finalConfig);
+  const metrics = createMetrics(finalConfig);
+  const tracing = finalConfig.observability.tracing.provider === "memory" ? new MemoryTracing() : new NoopTracing();
+  return createPlatformFromAdapters(db, cache, storage, email, queue, logger, metrics, tracing);
+}
+function createPlatformFromAdapters(db, cache, storage, email, queue, logger, metrics, tracing) {
+  return {
+    db,
+    cache,
+    storage,
+    email,
+    queue,
+    logger,
+    metrics,
+    tracing,
+    async healthCheck() {
+      const [dbHealth, cacheHealth, storageHealth, emailHealth, queueHealth, tracingHealth] = await Promise.all([
+        db.healthCheck(),
+        cache.healthCheck(),
+        storage.healthCheck(),
+        email.healthCheck(),
+        queue.healthCheck(),
+        tracing.healthCheck()
+      ]);
+      return {
+        healthy: dbHealth && cacheHealth && storageHealth && emailHealth && queueHealth && tracingHealth,
+        services: {
+          database: dbHealth,
+          cache: cacheHealth,
+          storage: storageHealth,
+          email: emailHealth,
+          queue: queueHealth,
+          tracing: tracingHealth
+        },
+        timestamp: Date.now()
+      };
+    },
+    async close() {
+      await Promise.all([db.close(), cache.close(), queue.close(), tracing.close()]);
+    }
+  };
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+
+// src/testing.ts
+function createTestPlatform() {
+  return createPlatform();
+}
+function createTestPlatformWithInternals() {
+  const memoryDb = new MemoryDatabase();
+  const memoryCache = new MemoryCache();
+  const memoryStorage = new MemoryStorage();
+  const memoryEmail = new MemoryEmail();
+  const memoryQueue = new MemoryQueue();
+  const platform = {
+    db: memoryDb,
+    cache: memoryCache,
+    storage: memoryStorage,
+    email: memoryEmail,
+    queue: memoryQueue,
+    async healthCheck() {
+      const [dbHealth, cacheHealth, storageHealth, emailHealth, queueHealth] = await Promise.all([
+        memoryDb.healthCheck(),
+        memoryCache.healthCheck(),
+        memoryStorage.healthCheck(),
+        memoryEmail.healthCheck(),
+        memoryQueue.healthCheck()
+      ]);
+      return {
+        healthy: dbHealth && cacheHealth && storageHealth && emailHealth && queueHealth,
+        services: {
+          database: dbHealth,
+          cache: cacheHealth,
+          storage: storageHealth,
+          email: emailHealth,
+          queue: queueHealth
+        },
+        timestamp: Date.now()
+      };
+    },
+    async close() {
+      await Promise.all([memoryDb.close(), memoryCache.close(), memoryQueue.close()]);
+    }
+  };
+  return {
+    ...platform,
+    memoryDb,
+    memoryCache,
+    memoryStorage,
+    memoryEmail,
+    memoryQueue
+  };
+}
+async function seedTestData(db, table, data) {
+  for (const row of data) {
+    await db.from(table).insert(row).execute();
+  }
+}
+async function clearTestPlatform(platform) {
+  platform.memoryDb.clear();
+  platform.memoryCache.clear();
+  platform.memoryStorage.clear();
+  platform.memoryEmail.clear();
+  platform.memoryQueue.clear();
+}
+async function waitForQueueDrain(platform, timeoutMs = 5e3) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const pendingJobs = platform.memoryQueue.getPendingJobs?.() ?? [];
+    if (pendingJobs.length === 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error(`Queue did not drain within ${timeoutMs}ms`);
+}
+function assertEmailSent(memoryEmail, expected) {
+  const emails = memoryEmail.getSentEmails();
+  const matchesTo = (emailTo, expectedTo) => {
+    if (!emailTo) return false;
+    if (Array.isArray(emailTo)) {
+      return emailTo.some((addr) => addr === expectedTo || typeof addr === "object" && addr.email === expectedTo);
+    }
+    return emailTo === expectedTo || typeof emailTo === "object" && emailTo.email === expectedTo;
+  };
+  const found = emails.find((email) => {
+    if (expected.to && !matchesTo(email.to, expected.to)) return false;
+    if (expected.subject) {
+      if (typeof expected.subject === "string" && email.subject !== expected.subject) return false;
+      if (expected.subject instanceof RegExp && !expected.subject.test(email.subject)) return false;
+    }
+    if (expected.bodyContains) {
+      const body = email.html || email.text || "";
+      if (!body.includes(expected.bodyContains)) return false;
+    }
+    return true;
+  });
+  if (!found) {
+    const emailSummary = emails.map((e) => `  - To: ${JSON.stringify(e.to)}, Subject: ${e.subject}`).join("\n");
+    throw new Error(
+      `Expected email not found.
+Expected: ${JSON.stringify(expected)}
+Sent emails:
+${emailSummary || "  (none)"}`
+    );
+  }
+}
+function createMockFn(implementation) {
+  const calls = [];
+  const fn = function(...args) {
+    calls.push(args);
+    return implementation?.(...args);
+  };
+  Object.defineProperty(fn, "calls", {
+    get: () => calls
+  });
+  Object.defineProperty(fn, "callCount", {
+    get: () => calls.length
+  });
+  Object.defineProperty(fn, "lastCall", {
+    get: () => calls[calls.length - 1]
+  });
+  fn.reset = () => {
+    calls.length = 0;
+  };
+  return fn;
+}
+export {
+  ConsoleEmail,
+  ConsoleLogger,
+  EnvSecrets,
+  MemoryCache,
+  MemoryDatabase,
+  MemoryEmail,
+  MemoryMetrics,
+  MemoryQueue,
+  MemorySecrets,
+  MemoryStorage,
+  NoopLogger,
+  NoopMetrics,
+  assertEmailSent,
+  clearTestPlatform,
+  createMockFn,
+  createPlatform,
+  createTestPlatform,
+  createTestPlatformWithInternals,
+  seedTestData,
+  waitForQueueDrain
+};
+//# sourceMappingURL=testing.mjs.map