@nextsparkjs/core 0.1.0-beta.1 → 0.1.0-beta.100

package/dist/lib/translations/registry.js

@@ -1,23 +1,11 @@
-import { TranslationService } from "../services/translation.service";
-function deepMerge(target, ...sources) {
-  if (!sources.length) return target;
-  const source = sources.shift();
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        if (!target[key]) {
-          Object.assign(target, { [key]: {} });
-        }
-        deepMerge(target[key], source[key]);
-      } else {
-        Object.assign(target, { [key]: source[key] });
-      }
-    }
-  }
-  return deepMerge(target, ...sources);
-}
-function isObject(item) {
-  return item !== null && typeof item === "object" && !Array.isArray(item);
+import { TranslationService } from "../services/translation.service.js";
+const DEBUG_I18N = process.env.NEXTSPARK_DEBUG_I18N === "true";
+const globalCache = globalThis;
+function getTranslationCache() {
+  if (!globalCache.__nextspark_translations_cache) {
+    globalCache.__nextspark_translations_cache = /* @__PURE__ */ new Map();
+  }
+  return globalCache.__nextspark_translations_cache;
 }
 function deepMergeMessages(target, source) {
   const result = { ...target };
@@ -45,141 +33,6 @@ function getLocaleFallbackChain(locale) {
   }
   return chain;
 }
-class TranslationRegistry {
-  translations = /* @__PURE__ */ new Map();
-  loadedNamespaces = /* @__PURE__ */ new Set();
-  coreTranslations = /* @__PURE__ */ new Map();
-  /**
-   * Load core translations from core/messages
-   */
-  async loadCoreTranslations(locale) {
-    if (this.coreTranslations.has(locale)) {
-      return this.coreTranslations.get(locale);
-    }
-    try {
-      const coreMessages = await import(`../../messages/${locale}/index.ts`);
-      const translations = coreMessages.default;
-      this.coreTranslations.set(locale, translations);
-      return translations;
-    } catch (error) {
-      console.error(`[TranslationRegistry] Failed to load core translations for ${locale}:`, error);
-      return {};
-    }
-  }
-  /**
-   * Load theme translations
-   * Uses auto-generated registry - NO runtime string interpolation
-   */
-  async loadThemeTranslations(locale) {
-    try {
-      const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME;
-      if (!activeTheme) {
-        console.warn("[TranslationRegistry] No active theme set");
-        return {};
-      }
-      return await TranslationService.load(activeTheme, locale);
-    } catch (error) {
-      console.warn(`[TranslationRegistry] Failed to load theme translations for ${locale}:`, error);
-      return {};
-    }
-  }
-  /**
-   * Load entity translations
-   */
-  async loadEntityTranslations(entity, locale) {
-    if (!entity.i18n) {
-      return {};
-    }
-    const { loaders, fallbackLocale = "en" } = entity.i18n;
-    const namespace = entity.slug;
-    const namespaceKey = `entity:${namespace}`;
-    if (this.translations.has(namespaceKey) && this.translations.get(namespaceKey).has(locale)) {
-      return this.translations.get(namespaceKey).get(locale);
-    }
-    try {
-      let translations = {};
-      if (loaders[locale]) {
-        const result = await loaders[locale]();
-        translations = result.default || result;
-      } else if (locale !== fallbackLocale && loaders[fallbackLocale]) {
-        console.warn(`[TranslationRegistry] Locale ${locale} not found for entity ${entity.slug}, using fallback ${fallbackLocale}`);
-        const result = await loaders[fallbackLocale]();
-        translations = result.default || result;
-      }
-      if (!this.translations.has(namespaceKey)) {
-        this.translations.set(namespaceKey, /* @__PURE__ */ new Map());
-      }
-      this.translations.get(namespaceKey).set(locale, translations);
-      return translations;
-    } catch (error) {
-      console.error(`[TranslationRegistry] Failed to load translations for entity ${entity.slug}:`, error);
-      return {};
-    }
-  }
-  /**
-   * Load all translations for a locale (core + theme + entities)
-   */
-  async loadAllTranslations(locale, entities = []) {
-    const coreTranslations = await this.loadCoreTranslations(locale);
-    const themeTranslations = await this.loadThemeTranslations(locale);
-    const entityTranslations = {};
-    for (const entity of entities) {
-      if (entity.i18n) {
-        const namespace = entity.slug;
-        const translations = await this.loadEntityTranslations(entity, locale);
-        if (Object.keys(translations).length > 0) {
-          entityTranslations[namespace] = translations;
-        }
-      }
-    }
-    return deepMerge({}, coreTranslations, themeTranslations, entityTranslations);
-  }
-  /**
-   * Get translation for a specific entity
-   */
-  async getEntityTranslation(_entityName, locale, entity) {
-    if (!entity) {
-      return {};
-    }
-    return this.loadEntityTranslations(entity, locale);
-  }
-  /**
-   * Clear translation cache
-   */
-  clearCache() {
-    this.translations.clear();
-    this.coreTranslations.clear();
-    this.loadedNamespaces.clear();
-  }
-  /**
-   * Clear cache for specific locale
-   */
-  clearLocaleCache(locale) {
-    this.coreTranslations.delete(locale);
-    for (const [namespace, localeMap] of this.translations.entries()) {
-      localeMap.delete(locale);
-      if (localeMap.size === 0) {
-        this.translations.delete(namespace);
-      }
-    }
-  }
-  /**
-   * Get loaded namespaces
-   */
-  getLoadedNamespaces() {
-    return Array.from(this.loadedNamespaces);
-  }
-  /**
-   * Check if namespace is loaded
-   */
-  isNamespaceLoaded(namespace) {
-    return this.loadedNamespaces.has(namespace);
-  }
-}
-const translationRegistry = new TranslationRegistry();
-async function loadTranslationsForLocale(locale, entities = []) {
-  return translationRegistry.loadAllTranslations(locale, entities);
-}
 async function loadCoreTranslations(locale) {
   try {
     const coreMessages = await import(`../../messages/${locale}/index.ts`);
@@ -193,15 +46,43 @@ function registerThemeMessages(locale, messages) {
   registeredThemeMessages[locale] = messages;
 }
 async function loadThemeTranslations(locale) {
+  const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME;
+  if (activeTheme) {
+    const registryMessages = await TranslationService.load(activeTheme, locale);
+    if (Object.keys(registryMessages).length > 0) {
+      return registryMessages;
+    }
+  }
   if (registeredThemeMessages[locale]) {
     return registeredThemeMessages[locale];
   }
   return {};
 }
-async function loadEntityTranslations(locale) {
-  return {};
+async function loadEntityTranslationsFromRegistry(locale) {
+  const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME || "default";
+  try {
+    const entityTranslations = await TranslationService.loadAllEntities(activeTheme, locale);
+    return entityTranslations;
+  } catch (error) {
+    if (DEBUG_I18N) {
+      console.warn(`[translations] Failed to load entity translations for ${locale}:`, error);
+    }
+    return {};
+  }
 }
 async function loadMergedTranslations(locale) {
+  const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME || "default";
+  const cacheKey = `${locale}-${activeTheme}`;
+  const cache = getTranslationCache();
+  if (cache.has(cacheKey)) {
+    if (DEBUG_I18N) {
+      console.log(`[i18n] Cache hit for ${cacheKey}`);
+    }
+    return cache.get(cacheKey);
+  }
+  if (DEBUG_I18N) {
+    console.log(`[i18n] Loading translations for ${cacheKey}`);
+  }
   const fallbackChain = getLocaleFallbackChain(locale);
   let mergedMessages = {};
   for (const fallbackLocale of [...fallbackChain].reverse()) {
@@ -215,19 +96,24 @@ async function loadMergedTranslations(locale) {
     const themeMessages = await loadThemeTranslations(locale);
     mergedMessages = deepMergeMessages(mergedMessages, themeMessages);
   } catch {
-    console.warn(`[translations] No theme messages for ${locale}`);
+    if (DEBUG_I18N) {
+      console.warn(`[translations] No theme messages for ${locale}`);
+    }
   }
   try {
-    const entityMessages = await loadEntityTranslations(locale);
-    mergedMessages = deepMergeMessages(mergedMessages, { entities: entityMessages });
+    const entityMessages = await loadEntityTranslationsFromRegistry(locale);
+    if (Object.keys(entityMessages).length > 0) {
+      mergedMessages = deepMergeMessages(mergedMessages, entityMessages);
+    }
   } catch {
   }
+  cache.set(cacheKey, mergedMessages);
+  if (DEBUG_I18N) {
+    console.log(`[i18n] Cached translations for ${cacheKey} with ${Object.keys(mergedMessages).length} namespaces`);
+  }
   return mergedMessages;
 }
 export {
-  TranslationRegistry,
   loadMergedTranslations,
-  loadTranslationsForLocale,
-  registerThemeMessages,
-  translationRegistry
+  registerThemeMessages
 };

package/dist/lib/user-data.d.ts

@@ -8,23 +8,41 @@ import type { PlanType, UserFlag } from './entities/types';
 import type { SessionUser } from './auth';
 /**
  * Interface for user plan and flag data
+ * @property plan - User's subscription plan type (free, starter, premium)
+ * @property flags - Array of feature flags assigned to the user
+ * @property cached - Whether this data was retrieved from cache vs database
  */
 export interface UserPlanData {
     plan: PlanType;
     flags: UserFlag[];
     cached: boolean;
 }
+/**
+ * Custom error class for user data operations
+ */
+export declare class UserDataError extends Error {
+    readonly userId: string;
+    readonly operation: string;
+    readonly originalError?: unknown;
+    constructor(message: string, userId: string, operation: string, originalError?: unknown);
+}
 /**
  * Get user plan and flags from database
  * Uses user_metas table to store plan and flags data
+ *
+ * @throws UserDataError in production when database operations fail
  */
 export declare function getUserPlanAndFlags(userId: string): Promise<UserPlanData>;
 /**
  * Update user plan in database
+ *
+ * @throws UserDataError in production when database operations fail
  */
 export declare function updateUserPlan(userId: string, plan: PlanType): Promise<boolean>;
 /**
  * Update user flags in database
+ *
+ * @throws UserDataError in production when database operations fail
  */
 export declare function updateUserFlags(userId: string, flags: UserFlag[]): Promise<boolean>;
 /**

package/dist/lib/user-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user-data.d.ts","sourceRoot":"","sources":["../../src/lib/user-data.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAgBzC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;CAChB;AAYD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA0E/E;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAyBrF;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAyBzF;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,GAAG;IACrF,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,QAAQ,EAAE,CAAA;CAClB,CAAC,CAQD"}
+{"version":3,"file":"user-data.d.ts","sourceRoot":"","sources":["../../src/lib/user-data.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AA6CzC;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,MAAM,EAAE,OAAO,CAAA;CAChB;AAGD;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;aAGpB,MAAM,EAAE,MAAM;aACd,SAAS,EAAE,MAAM;aACjB,aAAa,CAAC,EAAE,OAAO;gBAHvC,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,OAAO;CAK1C;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAmH/E;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CA+DrF;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CA+DzF;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,GAAG;IACrF,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,QAAQ,EAAE,CAAA;CAClB,CAAC,CAQD"}

package/dist/lib/user-data.js

@@ -1,13 +1,29 @@
-import { Pool } from "pg";
+import { getPool, isPoolHealthy } from "./db.js";
 const DEFAULT_PLAN = "free";
 const DEFAULT_FLAGS = [];
+const isDevelopment = process.env.NODE_ENV !== "production";
 const userDataCache = /* @__PURE__ */ new Map();
 const CACHE_TTL = 5 * 60 * 1e3;
-function getDatabasePool() {
-  return new Pool({
-    connectionString: process.env.DATABASE_URL,
-    ssl: process.env.NODE_ENV === "production" ? { rejectUnauthorized: false } : false
-  });
+const MAX_CACHE_SIZE = 1e4;
+function evictOldestCacheEntries() {
+  if (userDataCache.size <= MAX_CACHE_SIZE) {
+    return;
+  }
+  const entries = Array.from(userDataCache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+  const entriesToRemove = Math.max(1, Math.floor(entries.length * 0.1));
+  for (let i = 0; i < entriesToRemove; i++) {
+    userDataCache.delete(entries[i][0]);
+  }
+  console.log(`[UserData] Cache eviction: removed ${entriesToRemove} oldest entries, size now ${userDataCache.size}`);
+}
+class UserDataError extends Error {
+  constructor(message, userId, operation, originalError) {
+    super(message);
+    this.userId = userId;
+    this.operation = operation;
+    this.originalError = originalError;
+    this.name = "UserDataError";
+  }
 }
 async function getUserPlanAndFlags(userId) {
   const cached = userDataCache.get(userId);
@@ -18,8 +34,22 @@ async function getUserPlanAndFlags(userId) {
       cached: true
     };
   }
+  if (!isPoolHealthy()) {
+    const error = new UserDataError(
+      "Database pool is not healthy",
+      userId,
+      "getUserPlanAndFlags"
+    );
+    console.error("[UserData] Pool unhealthy:", error.message);
+    if (!isDevelopment) {
+      throw error;
+    }
+    console.warn("[UserData] Using defaults due to pool health check failure in development");
+    return { plan: DEFAULT_PLAN, flags: DEFAULT_FLAGS, cached: false };
+  }
+  let client = null;
   try {
-    const pool = getDatabasePool();
+    client = await getPool().connect();
     const query = `
       SELECT
         "metaKey",
@@ -28,7 +58,7 @@ async function getUserPlanAndFlags(userId) {
       WHERE "userId" = $1
       AND "metaKey" IN ('user_plan', 'user_flags')
     `;
-    const result = await pool.query(query, [userId]);
+    const result = await client.query(query, [userId]);
     let plan = DEFAULT_PLAN;
     let flags = DEFAULT_FLAGS;
     for (const row of result.rows) {
@@ -52,24 +82,55 @@ async function getUserPlanAndFlags(userId) {
       flags,
       timestamp: Date.now()
     });
-    await pool.end();
+    evictOldestCacheEntries();
     return {
       plan,
       flags,
       cached: false
     };
   } catch (error) {
-    console.error("Failed to get user plan and flags:", error);
+    const wrappedError = new UserDataError(
+      `Failed to get user plan and flags: ${error instanceof Error ? error.message : "Unknown error"}`,
+      userId,
+      "getUserPlanAndFlags",
+      error
+    );
+    console.error("[UserData] Error:", wrappedError.message, {
+      userId,
+      operation: "getUserPlanAndFlags",
+      originalError: error
+    });
+    if (!isDevelopment) {
+      throw wrappedError;
+    }
     return {
       plan: DEFAULT_PLAN,
       flags: DEFAULT_FLAGS,
       cached: false
     };
+  } finally {
+    if (client) {
+      client.release();
+    }
   }
 }
 async function updateUserPlan(userId, plan) {
+  if (!isPoolHealthy()) {
+    const error = new UserDataError(
+      "Database pool is not healthy",
+      userId,
+      "updateUserPlan"
+    );
+    console.error("[UserData] Pool unhealthy:", error.message);
+    if (!isDevelopment) {
+      throw error;
+    }
+    console.warn("[UserData] Using defaults due to pool health check failure in development");
+    return false;
+  }
+  let client = null;
   try {
-    const pool = getDatabasePool();
+    client = await getPool().connect();
     const query = `
       INSERT INTO "users_metas" ("userId", "metaKey", "metaValue", "dataType", "updatedAt")
       VALUES ($1, 'user_plan', $2, 'string', CURRENT_TIMESTAMP)
@@ -78,18 +139,49 @@ async function updateUserPlan(userId, plan) {
         "metaValue" = EXCLUDED."metaValue",
         "updatedAt" = CURRENT_TIMESTAMP
     `;
-    await pool.query(query, [userId, plan]);
-    await pool.end();
+    await client.query(query, [userId, plan]);
     userDataCache.delete(userId);
     return true;
   } catch (error) {
-    console.error("Failed to update user plan:", error);
+    const wrappedError = new UserDataError(
+      `Failed to update user plan: ${error instanceof Error ? error.message : "Unknown error"}`,
+      userId,
+      "updateUserPlan",
+      error
+    );
+    console.error("[UserData] Error:", wrappedError.message, {
+      userId,
+      operation: "updateUserPlan",
+      plan,
+      originalError: error
+    });
+    if (!isDevelopment) {
+      throw wrappedError;
+    }
     return false;
+  } finally {
+    if (client) {
+      client.release();
+    }
   }
 }
 async function updateUserFlags(userId, flags) {
+  if (!isPoolHealthy()) {
+    const error = new UserDataError(
+      "Database pool is not healthy",
+      userId,
+      "updateUserFlags"
+    );
+    console.error("[UserData] Pool unhealthy:", error.message);
+    if (!isDevelopment) {
+      throw error;
+    }
+    console.warn("[UserData] Using defaults due to pool health check failure in development");
+    return false;
+  }
+  let client = null;
   try {
-    const pool = getDatabasePool();
+    client = await getPool().connect();
     const query = `
       INSERT INTO "users_metas" ("userId", "metaKey", "metaValue", "dataType", "updatedAt")
       VALUES ($1, 'user_flags', $2, 'json', CURRENT_TIMESTAMP)
@@ -98,13 +190,30 @@ async function updateUserFlags(userId, flags) {
         "metaValue" = EXCLUDED."metaValue",
         "updatedAt" = CURRENT_TIMESTAMP
     `;
-    await pool.query(query, [userId, JSON.stringify(flags)]);
-    await pool.end();
+    await client.query(query, [userId, JSON.stringify(flags)]);
     userDataCache.delete(userId);
     return true;
   } catch (error) {
-    console.error("Failed to update user flags:", error);
+    const wrappedError = new UserDataError(
+      `Failed to update user flags: ${error instanceof Error ? error.message : "Unknown error"}`,
+      userId,
+      "updateUserFlags",
+      error
+    );
+    console.error("[UserData] Error:", wrappedError.message, {
+      userId,
+      operation: "updateUserFlags",
+      flags,
+      originalError: error
+    });
+    if (!isDevelopment) {
+      throw wrappedError;
+    }
     return false;
+  } finally {
+    if (client) {
+      client.release();
+    }
   }
 }
 async function enrichUserWithPlanData(user) {
@@ -116,6 +225,7 @@ async function enrichUserWithPlanData(user) {
   };
 }
 export {
+  UserDataError,
   enrichUserWithPlanData,
   getUserPlanAndFlags,
   updateUserFlags,

package/dist/lib/utils/cors.d.ts

@@ -0,0 +1,71 @@
+/**
+ * CORS Configuration Helper
+ *
+ * Single source of truth for all CORS origin checks.
+ * Merges origins from:
+ * 1. APP_URL environment variable (always included)
+ * 2. Core config (api.cors.allowedOrigins)
+ * 3. Theme extensions (api.cors.additionalOrigins)
+ * 4. Runtime env var (CORS_ADDITIONAL_ORIGINS)
+ */
+import type { ApplicationConfig } from '../config/config-types';
+/**
+ * Supported environments for CORS configuration
+ * - development: Local development
+ * - production: Production deployment
+ * - staging: Pre-production testing
+ * - qa: QA testing environment
+ */
+export type CorsEnvironment = 'development' | 'production' | 'staging' | 'qa';
+/**
+ * Normalize an origin URL by removing trailing slashes and converting to lowercase
+ *
+ * Browsers send Origin headers without trailing slashes (e.g., "http://localhost:8081")
+ * but environment variables like NEXT_PUBLIC_APP_URL may include them.
+ * This ensures consistent comparison for CORS validation.
+ *
+ * Also normalizes scheme and host to lowercase per RFC 3986.
+ *
+ * @param origin - Origin URL that may have trailing slash
+ * @returns Normalized origin URL, or empty string if input is invalid
+ *
+ * @example
+ * ```ts
+ * normalizeOrigin('http://localhost:3000/')  // 'http://localhost:3000'
+ * normalizeOrigin('http://localhost:3000')   // 'http://localhost:3000'
+ * normalizeOrigin('https://app.com///')      // 'https://app.com'
+ * normalizeOrigin('HTTP://LOCALHOST:3000')   // 'http://localhost:3000'
+ * normalizeOrigin('')                         // ''
+ * normalizeOrigin(null as any)               // ''
+ * ```
+ */
+export declare function normalizeOrigin(origin: string): string;
+/**
+ * Normalize environment string to a valid CorsEnvironment
+ * Maps staging/qa to use development origins, unknown environments default to development
+ *
+ * @param env - Raw environment string
+ * @returns Normalized environment key for config lookup
+ */
+export declare function normalizeCorsEnvironment(env: string): 'development' | 'production';
+/**
+ * Get merged CORS origins from config + theme + env vars
+ * Single source of truth for all CORS origin checks
+ *
+ * @param config - Application configuration (merged core + theme)
+ * @param env - Environment ('development', 'production', 'staging', 'qa')
+ * @returns Array of allowed origins (deduplicated)
+ *
+ * @example
+ * ```ts
+ * import { getCorsOrigins } from '@/lib/utils/cors'
+ * import { APP_CONFIG_MERGED } from '@/lib/config'
+ *
+ * const allowedOrigins = getCorsOrigins(APP_CONFIG_MERGED)
+ * if (allowedOrigins.includes(requestOrigin)) {
+ *   // Origin is allowed
+ * }
+ * ```
+ */
+export declare function getCorsOrigins(config: ApplicationConfig, env?: string): string[];
+//# sourceMappingURL=cors.d.ts.map

package/dist/lib/utils/cors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/cors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS,GAAG,IAAI,CAAA;AAc7E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAetD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,YAAY,CAkBlF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,EACzB,GAAG,GAAE,MAA8C,GAClD,MAAM,EAAE,CA+CV"}

package/dist/lib/utils/cors.js

@@ -0,0 +1,64 @@
+const DEV_LIKE_ENVIRONMENTS = ["development", "staging", "qa"];
+function isDebugEnabled() {
+  return process.env.NEXTSPARK_DEBUG_CORS === "true";
+}
+function normalizeOrigin(origin) {
+  if (!origin || typeof origin !== "string") {
+    return "";
+  }
+  try {
+    const url = new URL(origin);
+    return url.origin;
+  } catch {
+    return origin.toLowerCase().replace(/\/+$/, "");
+  }
+}
+function normalizeCorsEnvironment(env) {
+  const normalized = env.toLowerCase();
+  if (DEV_LIKE_ENVIRONMENTS.includes(normalized)) {
+    return "development";
+  }
+  if (normalized === "production") {
+    return "production";
+  }
+  if (isDebugEnabled()) {
+    console.log(`[cors] Unknown environment "${env}", defaulting to development`);
+  }
+  return "development";
+}
+function getCorsOrigins(config, env = process.env.NODE_ENV || "development") {
+  var _a;
+  const key = normalizeCorsEnvironment(env);
+  if (isDebugEnabled()) {
+    console.log(`[cors] Environment: ${env} -> normalized: ${key}`);
+  }
+  const coreOrigins = [...config.api.cors.allowedOrigins[key] || []];
+  const themeOrigins = [...((_a = config.api.cors.additionalOrigins) == null ? void 0 : _a[key]) || []];
+  const envVar = process.env.CORS_ADDITIONAL_ORIGINS || "";
+  const envOrigins = envVar.split(",").map((o) => o.trim()).filter(Boolean);
+  const appUrl = process.env.NEXT_PUBLIC_APP_URL;
+  const authUrl = process.env.BETTER_AUTH_URL;
+  const baseOrigins = [];
+  if (appUrl) baseOrigins.push(appUrl);
+  if (authUrl && authUrl !== appUrl) baseOrigins.push(authUrl);
+  const allOrigins = [...baseOrigins, ...coreOrigins, ...themeOrigins, ...envOrigins];
+  const origins = [...new Set(allOrigins.map(normalizeOrigin))];
+  if (isDebugEnabled()) {
+    console.log(`[cors] Merged origins (${origins.length}):`, origins);
+    console.log(`[cors]   - Base origins: ${baseOrigins.length}`);
+    console.log(`[cors]   - Core origins: ${coreOrigins.length}`);
+    console.log(`[cors]   - Theme origins: ${themeOrigins.length}`);
+    console.log(`[cors]   - Env origins: ${envOrigins.length}`);
+    for (const origin of origins) {
+      if (!origin.startsWith("http://") && !origin.startsWith("https://")) {
+        console.warn(`[cors] Invalid origin format: "${origin}" (must start with http:// or https://)`);
+      }
+    }
+  }
+  return origins;
+}
+export {
+  getCorsOrigins,
+  normalizeCorsEnvironment,
+  normalizeOrigin
+};

package/dist/lib/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core Utilities
+ *
+ * Re-export utility functions for convenience
+ */
+export { cn } from '../utils.js';
+export { getCorsOrigins, normalizeCorsEnvironment, normalizeOrigin, type CorsEnvironment } from './cors';
+export * from './config-merge';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAA;AAGxG,cAAc,gBAAgB,CAAA"}

package/dist/lib/utils/index.js

@@ -0,0 +1,9 @@
+import { cn } from "../utils.js";
+import { getCorsOrigins, normalizeCorsEnvironment, normalizeOrigin } from "./cors.js";
+export * from "./config-merge.js";
+export {
+  cn,
+  getCorsOrigins,
+  normalizeCorsEnvironment,
+  normalizeOrigin
+};