@nextsparkjs/core 0.1.0-beta.7 → 0.1.0-beta.70

package/dist/lib/teams/teams.api.js

@@ -0,0 +1,96 @@
+class TeamsAPI {
+  // =============================================================================
+  // USER TEAMS (Normal user scope)
+  // =============================================================================
+  /**
+   * Fetch current user's teams
+   *
+   * @returns Array of teams the user belongs to
+   * @throws Error if request fails
+   *
+   * @example
+   * const teams = await TeamsAPI.getUserTeams()
+   */
+  static async getUserTeams() {
+    const response = await fetch("/api/v1/teams");
+    if (!response.ok) {
+      throw new Error("Failed to fetch teams");
+    }
+    const result = await response.json();
+    return result.data || result.teams || [];
+  }
+  /**
+   * Create a new team
+   *
+   * @param data - Team creation data
+   * @returns Created team
+   * @throws Error if request fails
+   */
+  static async createTeam(data) {
+    const response = await fetch("/api/v1/teams", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Failed to create team");
+    }
+    const result = await response.json();
+    return result.data || result.team;
+  }
+  // =============================================================================
+  // ADMIN TEAMS (Superadmin/Developer scope)
+  // =============================================================================
+  /**
+   * Fetch all teams (admin only)
+   *
+   * Requires superadmin or developer role.
+   * Supports search, filtering by type, and pagination.
+   *
+   * @param params - Query parameters
+   * @returns Teams response with counts and pagination
+   * @throws Error if request fails or user is not authorized
+   *
+   * @example
+   * // Get all user teams
+   * const response = await TeamsAPI.getAdminTeams({ type: 'user' })
+   *
+   * // Search teams
+   * const response = await TeamsAPI.getAdminTeams({ search: 'acme' })
+   *
+   * // Paginate
+   * const response = await TeamsAPI.getAdminTeams({ page: 2, limit: 20 })
+   */
+  static async getAdminTeams(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.search) {
+      searchParams.set("search", params.search);
+    }
+    if (params.type) {
+      searchParams.set("type", params.type);
+    }
+    if (params.page) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params.limit) {
+      searchParams.set("limit", String(params.limit));
+    }
+    const queryString = searchParams.toString();
+    const url = `/api/superadmin/teams${queryString ? `?${queryString}` : ""}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      if (response.status === 403) {
+        throw new Error("Not authorized to view all teams");
+      }
+      if (response.status === 401) {
+        throw new Error("Authentication required");
+      }
+      throw new Error("Failed to fetch teams");
+    }
+    return response.json();
+  }
+}
+export {
+  TeamsAPI
+};

package/dist/lib/teams/teams.keys.js

@@ -0,0 +1,35 @@
+const teamsKeys = {
+  /**
+   * Base key for all team queries
+   * Use to invalidate ALL team-related caches
+   */
+  all: ["teams"],
+  /**
+   * User's teams (normal user scope)
+   * Endpoint: GET /api/v1/teams
+   */
+  user: () => [...teamsKeys.all, "user"],
+  /**
+   * Single team by ID
+   */
+  detail: (teamId) => [...teamsKeys.all, "detail", teamId],
+  /**
+   * Admin teams scope (superadmin/developer)
+   * Base key for all admin team queries
+   */
+  admin: () => [...teamsKeys.all, "admin"],
+  /**
+   * Admin teams list with parameters
+   * Endpoint: GET /api/superadmin/teams
+   * Used by superadmin management page
+   */
+  adminList: (params) => [...teamsKeys.admin(), "list", params],
+  /**
+   * Admin teams search (optimized for dropdowns)
+   * Uses simplified key for search-based caching
+   */
+  adminSearch: (search) => [...teamsKeys.admin(), "search", search]
+};
+export {
+  teamsKeys
+};

package/dist/lib/teams/types.js

@@ -1,4 +1,4 @@
-import { APP_CONFIG_MERGED } from "../config/config-sync";
+import { APP_CONFIG_MERGED } from "../config/config-sync.js";
 function isValidTeamRole(role) {
   var _a;
   const availableRoles = ((_a = APP_CONFIG_MERGED.teamRoles) == null ? void 0 : _a.availableTeamRoles) ?? [];

package/dist/lib/template-resolver.js

@@ -1,10 +1,10 @@
 import React from "react";
-import { TemplateService } from "./services/template.service";
+import { TemplateService } from "./services/template.service.js";
 import {
   canOverrideComponent,
   canOverrideMetadata,
   getProtectionLevel
-} from "../config/protected-paths";
+} from "../config/protected-paths.js";
 function getTemplateOrDefault(appPath, defaultComponent) {
   console.log(`[getTemplateOrDefault] Called for: ${appPath}`);
   if (!canOverrideComponent(appPath)) {

package/dist/lib/test/index.js

@@ -1,50 +1,15 @@
+export * from "../selectors/index.js";
 import {
-  createSelectorHelpers,
-  getNestedValue,
-  replacePlaceholders
-} from "./selector-factory";
-import {
-  CORE_SELECTORS
-} from "./core-selectors";
-import {
-  SELECTORS,
-  sel,
-  s,
-  selDev,
-  cySelector,
-  entitySelectors
-} from "./selectors";
-import {
-  createTestId,
-  createCyId,
   createStateAttr,
   createPriorityAttr,
   createTestingProps,
   createAriaLabel,
-  createEntityCyId,
-  createEntityTestingHelper,
-  testingPatterns,
   keyboardHelpers
-} from "./utils";
+} from "./utils.js";
 export {
-  CORE_SELECTORS,
-  SELECTORS,
   createAriaLabel,
-  createCyId,
-  createEntityCyId,
-  createEntityTestingHelper,
   createPriorityAttr,
-  createSelectorHelpers,
   createStateAttr,
-  createTestId,
   createTestingProps,
-  cySelector,
-  entitySelectors,
-  getNestedValue,
-  keyboardHelpers,
-  replacePlaceholders,
-  s,
-  sel,
-  selDev,
-  testingPatterns
+  keyboardHelpers
 };

package/dist/lib/test/utils.js

@@ -1,15 +1,6 @@
 const isDevelopment = process.env.NODE_ENV === "development";
 const isTest = process.env.NODE_ENV === "test";
 const enableTestingAttributes = isDevelopment || isTest;
-function createTestId(component, element, action) {
-  if (!enableTestingAttributes) return void 0;
-  const parts = [component, element, action].filter(Boolean);
-  return parts.join("-");
-}
-function createCyId(domain, element) {
-  if (!enableTestingAttributes) return void 0;
-  return `${domain}-${element}`;
-}
 function createStateAttr(state) {
   return state;
 }
@@ -45,54 +36,6 @@ function createAriaLabel(template, values) {
     return String(values[key] ?? match);
   });
 }
-const testingPatterns = {
-  // Task/Todo components
-  task: {
-    card: (taskId) => createTestingProps({
-      testId: createTestId("task", "card"),
-      cyId: createCyId("task", "item"),
-      taskId
-    }),
-    checkbox: () => createTestingProps({
-      testId: createTestId("task", "checkbox"),
-      cyId: createCyId("task", "toggle")
-    }),
-    title: () => createTestingProps({
-      testId: createTestId("task", "title"),
-      cyId: createCyId("task", "title")
-    }),
-    deleteButton: () => createTestingProps({
-      testId: createTestId("task", "delete", "button"),
-      cyId: createCyId("task", "delete")
-    })
-  },
-  // Navigation components
-  nav: {
-    searchDropdown: () => createTestingProps({
-      testId: createTestId("nav", "search", "dropdown"),
-      cyId: createCyId("nav", "search")
-    }),
-    notifications: () => createTestingProps({
-      testId: createTestId("nav", "notifications", "button"),
-      cyId: createCyId("nav", "notifications")
-    }),
-    userMenu: () => createTestingProps({
-      testId: createTestId("nav", "user", "menu"),
-      cyId: createCyId("nav", "user-menu")
-    })
-  },
-  // Form components
-  form: {
-    input: (fieldName) => createTestingProps({
-      testId: createTestId("form", fieldName, "input"),
-      cyId: createCyId("form", fieldName)
-    }),
-    submitButton: () => createTestingProps({
-      testId: createTestId("form", "submit", "button"),
-      cyId: createCyId("form", "submit")
-    })
-  }
-};
 const keyboardHelpers = {
   /**
    * Handle Enter and Space key activation
@@ -134,57 +77,10 @@ const keyboardHelpers = {
     };
   }
 };
-function createEntityCyId(entitySlug, component, detail) {
-  if (!enableTestingAttributes) return void 0;
-  const parts = [entitySlug, component, detail].filter(Boolean);
-  return parts.join("-");
-}
-function createEntityTestingHelper(entitySlug) {
-  return {
-    // Generic (framework-agnostic)
-    get: (component, detail) => createEntityCyId(entitySlug, component, detail),
-    // Page
-    page: () => createEntityCyId(entitySlug, "page"),
-    formPage: () => createEntityCyId(entitySlug, "form-page"),
-    // Form
-    form: () => createEntityCyId(entitySlug, "form"),
-    formSubmit: () => createEntityCyId(entitySlug, "form-submit"),
-    formCancel: () => createEntityCyId(entitySlug, "form-cancel"),
-    // Fields
-    field: (name) => createEntityCyId(entitySlug, "field", name),
-    fieldOption: (name, value) => createEntityCyId(entitySlug, `field-${name}-option`, value),
-    fieldError: (name) => createEntityCyId(entitySlug, `field-${name}`, "error"),
-    // Sections
-    section: (name) => createEntityCyId(entitySlug, "section", name),
-    // Card
-    card: (id) => createEntityCyId(entitySlug, "card", id),
-    // List/Table
-    table: () => createEntityCyId(entitySlug, "table"),
-    row: (id) => createEntityCyId(entitySlug, "row", id),
-    createBtn: () => createEntityCyId(entitySlug, "create-btn"),
-    searchInput: () => createEntityCyId(entitySlug, "search-input"),
-    // Filters
-    filter: (field) => createEntityCyId(entitySlug, "filter", field),
-    filterTrigger: (field) => createEntityCyId(entitySlug, `filter-${field}`, "trigger"),
-    filterOption: (field, value) => createEntityCyId(entitySlug, `filter-${field}-option`, value),
-    // Actions
-    action: (action, id) => createEntityCyId(entitySlug, `action-${action}`, id),
-    actionsTrigger: (id) => createEntityCyId(entitySlug, "actions-trigger", id),
-    // Dialogs
-    confirmDelete: () => createEntityCyId(entitySlug, "confirm-delete"),
-    confirmDeleteBtn: () => createEntityCyId(entitySlug, "confirm-delete-btn"),
-    cancelDeleteBtn: () => createEntityCyId(entitySlug, "cancel-delete-btn")
-  };
-}
 export {
   createAriaLabel,
-  createCyId,
-  createEntityCyId,
-  createEntityTestingHelper,
   createPriorityAttr,
   createStateAttr,
-  createTestId,
   createTestingProps,
-  keyboardHelpers,
-  testingPatterns
+  keyboardHelpers
 };

package/dist/lib/theme/ThemeProvider.js

@@ -1,9 +1,9 @@
 "use client";
 import { jsx } from "react/jsx-runtime";
 import React, { createContext, useContext, useEffect, useState } from "react";
-import { ThemeService } from "../services/theme.service";
-import { ImportResolverProvider } from "./import-resolver";
-import { applyThemeStyles } from "./theme-loader";
+import { ThemeService } from "../services/theme.service.js";
+import { ImportResolverProvider } from "./import-resolver.js";
+import { applyThemeStyles } from "./theme-loader.js";
 const ThemeContext = createContext(null);
 function ThemeProvider({ children, defaultTheme = "default" }) {
   const [currentTheme, setCurrentTheme] = useState(null);

package/dist/lib/theme/get-default-theme-mode.js

@@ -1,5 +1,5 @@
-import { auth } from "../auth";
-import { ThemeService } from "../services/theme.service";
+import { auth } from "../auth.js";
+import { ThemeService } from "../services/theme.service.js";
 import { headers } from "next/headers";
 async function getDefaultThemeMode() {
   var _a, _b, _c;

package/dist/lib/theme/theme-loader.js

@@ -1,5 +1,5 @@
-import { ThemeService } from "../services/theme.service";
-import { preloadThemeOverrides, clearOverrideCache } from "./override-resolver";
+import { ThemeService } from "../services/theme.service.js";
+import { preloadThemeOverrides, clearOverrideCache } from "./override-resolver.js";
 function getThemes() {
   return ThemeService.getAll();
 }

package/dist/lib/translations/i18n-integration.js

@@ -1,6 +1,6 @@
-import { TranslationService } from "../services/translation.service";
-import { loadMergedTranslations } from "./registry";
-import { getAllEntityConfigs, ensureInitialized } from "../entities/registry";
+import { TranslationService } from "../services/translation.service.js";
+import { loadMergedTranslations } from "./registry.js";
+import { getAllEntityConfigs, ensureInitialized } from "../entities/registry.js";
 async function loadAllI18nTranslations(locale) {
   try {
     await ensureEntitiesInitialized();
@@ -41,7 +41,7 @@ function getOptimizedNamespaces(pathname) {
     if (pathname.startsWith("/dashboard")) {
       console.log(`[i18n-integration] \u{1F4F1} Dashboard detected \u2192 Loading authenticated user namespaces`);
       return {
-        core: ["common", "dashboard", "settings", "public", "validation", "teams"],
+        core: ["common", "dashboard", "settings", "public", "validation", "teams", "admin"],
         entities: [],
         // Entities will be loaded dynamically
         strategy: "DASHBOARD_AUTHENTICATED"

package/dist/lib/translations/registry.js

@@ -1,4 +1,12 @@
-import { TranslationService } from "../services/translation.service";
+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 };
   for (const key of Object.keys(source)) {
@@ -56,11 +64,25 @@ async function loadEntityTranslationsFromRegistry(locale) {
     const entityTranslations = await TranslationService.loadAllEntities(activeTheme, locale);
     return entityTranslations;
   } catch (error) {
-    console.warn(`[translations] Failed to load entity translations for ${locale}:`, 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()) {
@@ -74,7 +96,9 @@ 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 loadEntityTranslationsFromRegistry(locale);
@@ -83,6 +107,10 @@ async function loadMergedTranslations(locale) {
     }
   } catch {
   }
+  cache.set(cacheKey, mergedMessages);
+  if (DEBUG_I18N) {
+    console.log(`[i18n] Cached translations for ${cacheKey} with ${Object.keys(mergedMessages).length} namespaces`);
+  }
   return mergedMessages;
 }
 export {

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,