@nextsparkjs/core 0.1.0-beta.75 → 0.1.0-beta.77

package/dist/lib/services/user.service.d.ts

@@ -0,0 +1,233 @@
+/**
+ * User Service
+ *
+ * Provides core user management functions including CRUD operations
+ * and metadata management for users.
+ *
+ * @module UserService
+ */
+import type { User, UserRole } from '../../types/user.types';
+import type { MetaDataType } from '../../types/meta.types';
+export interface UpdateUserPayload {
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    image?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+    role?: UserRole;
+}
+export declare class UserService {
+    /**
+     * Get user by ID or email
+     *
+     * @param identifier - User ID or email address
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns User object or null if not found
+     *
+     * @example
+     * const user = await UserService.getUser('user-id-123', 'current-user-id')
+     * const userByEmail = await UserService.getUser('user@example.com', 'current-user-id')
+     */
+    static getUser(identifier: string, currentUserId: string): Promise<User | null>;
+    /**
+     * Get user by email only (convenience method)
+     *
+     * @param email - User email address
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns User object or null if not found
+     *
+     * @example
+     * const user = await UserService.getUserByEmail('user@example.com', 'current-user-id')
+     */
+    static getUserByEmail(email: string, currentUserId: string): Promise<User | null>;
+    /**
+     * Get user by ID only (convenience method)
+     *
+     * @param userId - User ID
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns User object or null if not found
+     *
+     * @example
+     * const user = await UserService.getUserById('user-id-123', 'current-user-id')
+     */
+    static getUserById(userId: string, currentUserId: string): Promise<User | null>;
+    /**
+     * Get multiple users by IDs (bulk operation)
+     *
+     * @param userIds - Array of user IDs
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns Array of user objects
+     *
+     * @example
+     * const users = await UserService.getUsersByIds(['id-1', 'id-2'], 'current-user-id')
+     */
+    static getUsersByIds(userIds: string[], currentUserId: string): Promise<User[]>;
+    /**
+     * Update user information
+     *
+     * @param userId - ID of the user to update
+     * @param updates - Partial user data to update
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns Updated user object
+     *
+     * @example
+     * const updated = await UserService.updateUser(
+     *   'user-id-123',
+     *   { firstName: 'John', lastName: 'Doe' },
+     *   'current-user-id'
+     * )
+     */
+    static updateUser(userId: string, updates: UpdateUserPayload, currentUserId: string): Promise<User>;
+    /**
+     * Get all metadata for a user
+     * Wrapper around MetaService for user-specific metadata
+     *
+     * @param userId - ID of the user
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @param includePrivate - Whether to include private metadata (default: false)
+     * @returns Object with metadata key-value pairs
+     *
+     * @example
+     * const metas = await UserService.getUserMetas('user-id-123', 'current-user-id')
+     * // Returns: { theme: 'dark', notifications: true, ... }
+     */
+    static getUserMetas(userId: string, currentUserId: string, includePrivate?: boolean): Promise<Record<string, unknown>>;
+    /**
+     * Get specific metadata value for a user
+     *
+     * @param userId - ID of the user
+     * @param metaKey - The metadata key to fetch
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns Metadata value or null if not found
+     *
+     * @example
+     * const theme = await UserService.getUserMeta('user-id-123', 'theme', 'current-user-id')
+     * // Returns: 'dark'
+     */
+    static getUserMeta(userId: string, metaKey: string, currentUserId: string): Promise<unknown>;
+    /**
+     * Get specific metadata keys for a user
+     *
+     * @param userId - ID of the user
+     * @param metaKeys - Array of metadata keys to fetch
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @returns Object with requested metadata key-value pairs
+     *
+     * @example
+     * const metas = await UserService.getSpecificUserMetas(
+     *   'user-id-123',
+     *   ['theme', 'language'],
+     *   'current-user-id'
+     * )
+     * // Returns: { theme: 'dark', language: 'en' }
+     */
+    static getSpecificUserMetas(userId: string, metaKeys: string[], currentUserId: string): Promise<Record<string, unknown>>;
+    /**
+     * Set or update a single user metadata value
+     *
+     * @param userId - ID of the user
+     * @param metaKey - The metadata key
+     * @param metaValue - The metadata value (will be stored as JSON)
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @param options - Additional options (isPublic, isSearchable, dataType)
+     *
+     * @example
+     * await UserService.updateUserMeta(
+     *   'user-id-123',
+     *   'theme',
+     *   'dark',
+     *   'current-user-id',
+     *   { isPublic: false }
+     * )
+     */
+    static updateUserMeta(userId: string, metaKey: string, metaValue: unknown, currentUserId: string, options?: {
+        isPublic?: boolean;
+        isSearchable?: boolean;
+        dataType?: MetaDataType;
+    }): Promise<void>;
+    /**
+     * Set or update multiple user metadata values in bulk
+     * More efficient than calling updateUserMeta multiple times
+     *
+     * @param userId - ID of the user
+     * @param metas - Object with metadata key-value pairs
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @param options - Additional options (isPublic, isSearchable, dataType)
+     *
+     * @example
+     * await UserService.updateUserMetas(
+     *   'user-id-123',
+     *   { theme: 'dark', language: 'en', notifications: true },
+     *   'current-user-id'
+     * )
+     */
+    static updateUserMetas(userId: string, metas: Record<string, unknown>, currentUserId: string, options?: {
+        isPublic?: boolean;
+        isSearchable?: boolean;
+        dataType?: MetaDataType;
+    }): Promise<void>;
+    /**
+     * Delete a specific user metadata key
+     *
+     * @param userId - ID of the user
+     * @param metaKey - The metadata key to delete
+     * @param currentUserId - ID of the user making the request (for RLS)
+     *
+     * @example
+     * await UserService.deleteUserMeta('user-id-123', 'theme', 'current-user-id')
+     */
+    static deleteUserMeta(userId: string, metaKey: string, currentUserId: string): Promise<void>;
+    /**
+     * Delete all metadata for a user
+     *
+     * @param userId - ID of the user
+     * @param currentUserId - ID of the user making the request (for RLS)
+     *
+     * @example
+     * await UserService.deleteAllUserMetas('user-id-123', 'current-user-id')
+     */
+    static deleteAllUserMetas(userId: string, currentUserId: string): Promise<void>;
+    /**
+     * Get metadata for multiple users in bulk (solves N+1 query problem)
+     *
+     * @param userIds - Array of user IDs
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @param includePrivate - Whether to include private metadata (default: false)
+     * @returns Object mapping user IDs to their metadata
+     *
+     * @example
+     * const metas = await UserService.getBulkUserMetas(
+     *   ['user-1', 'user-2'],
+     *   'current-user-id'
+     * )
+     * // Returns: { 'user-1': { theme: 'dark' }, 'user-2': { theme: 'light' } }
+     */
+    static getBulkUserMetas(userIds: string[], currentUserId: string, includePrivate?: boolean): Promise<Record<string, Record<string, unknown>>>;
+    /**
+     * Search users by metadata
+     *
+     * @param metaKey - The metadata key to search
+     * @param metaValue - The metadata value to match
+     * @param currentUserId - ID of the user making the request (for RLS)
+     * @param limit - Maximum number of results (default: 100)
+     * @param offset - Offset for pagination (default: 0)
+     * @returns Object with user IDs and total count
+     *
+     * @example
+     * const result = await UserService.searchUsersByMeta(
+     *   'theme',
+     *   'dark',
+     *   'current-user-id',
+     *   50,
+     *   0
+     * )
+     * // Returns: { entities: ['user-1', 'user-2'], total: 2 }
+     */
+    static searchUsersByMeta(metaKey: string, metaValue: unknown, currentUserId: string, limit?: number, offset?: number): Promise<{
+        entities: string[];
+        total: number;
+    }>;
+}
+//# sourceMappingURL=user.service.d.ts.map

package/dist/lib/services/user.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.service.d.ts","sourceRoot":"","sources":["../../../src/lib/services/user.service.ts"],"names":[],"mappings":"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"}

package/dist/lib/teams/actions.d.ts

@@ -0,0 +1,152 @@
+/**
+ * @deprecated DEPRECATED - Use service layer instead
+ *
+ * This file is DEPRECATED. All functions have been migrated to the service layer:
+ * - createTeam → TeamService.create()
+ * - getGlobalTeam → TeamService.getGlobal()
+ * - hasGlobalTeam → TeamService.hasGlobal()
+ * - getUserTeamRole → TeamMemberService.getRole(teamId, userId) [NOTE: param order changed!]
+ * - checkTeamPermission → TeamMemberService.hasPermission()
+ * - isTeamMember → TeamMemberService.isMember(teamId, userId) [NOTE: param order changed!]
+ * - isSlugAvailable → TeamService.isSlugAvailable()
+ * - switchActiveTeam → TeamService.switchActive()
+ * - deleteTeam → TeamService.delete()
+ *
+ * Import from '../services' instead:
+ * import { TeamService, TeamMemberService } from '../services'
+ *
+ * This file will be removed in a future version.
+ */
+import type { Team, TeamRole } from './types';
+/**
+ * Create Team (UNIFIED function - no type distinction)
+ * Used for signup and manual team creation
+ *
+ * @param userId - The ID of the user creating the team
+ * @param name - Optional team name (defaults to user's name + Team)
+ * @returns The created Team
+ */
+export declare function createTeam(userId: string, name?: string): Promise<Team>;
+/**
+ * Get the global team (for single-tenant mode)
+ * Returns the first team found (should be the only one)
+ *
+ * @returns The global team or null if none exists
+ */
+export declare function getGlobalTeam(): Promise<Team | null>;
+/**
+ * Check if global team exists (for single-tenant mode)
+ * Used to determine if public signup should be blocked
+ *
+ * @returns True if a team exists, false otherwise
+ */
+export declare function hasGlobalTeam(): Promise<boolean>;
+/**
+ * Add user to the global team (for single-tenant invite flow)
+ *
+ * @param userId - The user ID to add
+ * @param role - The role to assign (default: 'member')
+ * @param invitedBy - The user ID who invited them
+ */
+export declare function addUserToGlobalTeam(userId: string, role?: TeamRole, invitedBy?: string): Promise<void>;
+/**
+ * Check if user has required permission in team
+ *
+ * @param userId - The user ID
+ * @param teamId - The team ID
+ * @param requiredRoles - Array of roles that are allowed
+ * @returns True if user has permission, false otherwise
+ */
+export declare function checkTeamPermission(userId: string, teamId: string, requiredRoles?: TeamRole[]): Promise<boolean>;
+/**
+ * Get user's role in a team
+ *
+ * @param userId - The user ID
+ * @param teamId - The team ID
+ * @returns The user's role or null if not a member
+ */
+export declare function getUserTeamRole(userId: string, teamId: string): Promise<TeamRole | null>;
+/**
+ * Check if user is a member of a team
+ *
+ * @param userId - The user ID
+ * @param teamId - The team ID
+ * @returns True if user is a member, false otherwise
+ */
+export declare function isTeamMember(userId: string, teamId: string): Promise<boolean>;
+/**
+ * Get all teams for a user with detailed information
+ *
+ * @param userId - The user ID
+ * @returns Array of teams with membership details
+ */
+export declare function getUserTeamsWithDetails(userId: string): Promise<{
+    memberCount: number;
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    ownerId: string;
+    avatarUrl: string | null;
+    settings: Record<string, any>;
+    createdAt: string;
+    updatedAt: string;
+    userRole: TeamRole;
+    joinedAt: string;
+}[]>;
+/**
+ * Get team by ID with member count
+ *
+ * @param teamId - The team ID
+ * @param userId - The user ID (for RLS)
+ * @returns Team with member count or null
+ */
+export declare function getTeamWithMemberCount(teamId: string, userId: string): Promise<(Team & {
+    memberCount: number;
+}) | null>;
+/**
+ * Get team members with user details
+ *
+ * @param teamId - The team ID
+ * @param userId - The requesting user ID (for RLS)
+ * @returns Array of team members with user information
+ */
+export declare function getTeamMembersWithUsers(teamId: string, userId: string): Promise<{
+    id: string;
+    teamId: string;
+    userId: string;
+    role: TeamRole;
+    invitedBy: string | null;
+    joinedAt: string;
+    createdAt: string;
+    updatedAt: string;
+    userName: string | null;
+    userEmail: string;
+    userImage: string | null;
+}[]>;
+/**
+ * Check if slug is available (not used by another team)
+ *
+ * @param slug - The slug to check
+ * @param excludeTeamId - Optional team ID to exclude from check (for updates)
+ * @returns True if slug is available, false otherwise
+ */
+export declare function isSlugAvailable(slug: string, excludeTeamId?: string): Promise<boolean>;
+/**
+ * Switch active team (for session management)
+ * This would typically update the session with the new team context
+ *
+ * @param userId - The user ID
+ * @param teamId - The team ID to switch to
+ * @returns True if successful, throws error otherwise
+ */
+export declare function switchActiveTeam(userId: string, teamId: string): Promise<boolean>;
+/**
+ * Delete team
+ * No special protection needed (all teams can be deleted)
+ *
+ * @param teamId - The team ID
+ * @param userId - The user ID (must be owner)
+ */
+export declare function deleteTeam(teamId: string, userId: string): Promise<void>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/lib/teams/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/lib/teams/actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAc,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEzD;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6D7E;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAW1D;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAGtD;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,QAAmB,EACzB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,aAAa,GAAE,QAAQ,EAAuB,GAC7C,OAAO,CAAC,OAAO,CAAC,CAYlB;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAQ1B;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CAQlB;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,MAAM;;QAEpD,MAAM;UACJ,MAAM;UACN,MAAM;iBACC,MAAM,GAAG,IAAI;aACjB,MAAM;eACJ,MAAM,GAAG,IAAI;cACd,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;eAClB,MAAM;eACN,MAAM;cACP,QAAQ;cACR,MAAM;KAyBnB;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,IAAI,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,CAAC,CAqBlD;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM;QAGR,MAAM;YACF,MAAM;YACN,MAAM;UACR,QAAQ;eACH,MAAM,GAAG,IAAI;cACd,MAAM;eACL,MAAM;eACN,MAAM;cACP,MAAM,GAAG,IAAI;eACZ,MAAM;eACN,MAAM,GAAG,IAAI;KAuB3B;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC,CAclB;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CAalB;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC,CA2Bf"}

package/dist/lib/teams/helpers.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Teams Mode Helper Functions
+ *
+ * Helpers para verificar capacidades segun el modo de teams configurado.
+ * Estas funciones son puras y no tienen side effects.
+ *
+ * SIMPLIFIED: Only 3 modes (single-user, single-tenant, multi-tenant)
+ * No team types (personal/work distinction removed)
+ */
+import type { TeamsMode, TeamsConfigOptions } from '../config/types';
+/**
+ * Determina si el modo permite invitar miembros al team
+ *
+ * @param mode - El modo de teams configurado
+ * @returns true si el modo permite invitaciones
+ *
+ * @example
+ * ```typescript
+ * const canInvite = canInviteMembers('single-tenant') // true
+ * const canInvite = canInviteMembers('single-user')   // false
+ * ```
+ */
+export declare function canInviteMembers(mode: TeamsMode): boolean;
+/**
+ * Determina si el modo permite cambiar entre teams
+ *
+ * @param mode - El modo de teams configurado
+ * @returns true si el usuario puede tener multiples teams
+ *
+ * @example
+ * ```typescript
+ * const canSwitch = canSwitchTeams('multi-tenant') // true
+ * const canSwitch = canSwitchTeams('single-tenant') // false
+ * ```
+ */
+export declare function canSwitchTeams(mode: TeamsMode): boolean;
+/**
+ * Determina si el modo permite crear nuevos teams
+ *
+ * @param mode - El modo de teams configurado
+ * @returns true si el modo soporta creacion de teams
+ *
+ * Nota: Esto solo indica si el MODO permite crear teams.
+ * Use canUserCreateTeam() para verificar si un USUARIO especifico puede crear.
+ *
+ * @example
+ * ```typescript
+ * const canCreate = canCreateTeams('multi-tenant') // true
+ * const canCreate = canCreateTeams('single-tenant') // false
+ * ```
+ */
+export declare function canCreateTeams(mode: TeamsMode): boolean;
+/**
+ * Determina si se crea un team en signup
+ *
+ * @param mode - El modo de teams configurado
+ * @returns true si el signup debe crear un team
+ *
+ * Nota: single-tenant retorna false porque:
+ * - Primer usuario: crea team global (caso especial)
+ * - Usuarios siguientes: solo pueden registrarse via invitacion
+ *
+ * @example
+ * ```typescript
+ * const creates = createsTeamOnSignup('multi-tenant') // true
+ * const creates = createsTeamOnSignup('single-tenant') // false
+ * ```
+ */
+export declare function createsTeamOnSignup(mode: TeamsMode): boolean;
+/**
+ * Determina si el signup publico esta restringido
+ *
+ * En modo single-tenant, el signup publico solo esta permitido
+ * para el primer usuario. Despues, solo se puede registrar via invitacion.
+ *
+ * @param mode - El modo de teams configurado
+ * @returns true si el signup publico esta restringido (requiere verificacion adicional)
+ *
+ * @example
+ * ```typescript
+ * const restricted = isPublicSignupRestricted('single-tenant') // true
+ * const restricted = isPublicSignupRestricted('multi-tenant') // false
+ * ```
+ */
+export declare function isPublicSignupRestricted(mode: TeamsMode): boolean;
+/**
+ * NUEVA FUNCION: Determina si un usuario especifico puede crear un nuevo team
+ *
+ * Considera el modo, la configuracion allowCreateTeams, y el estado actual del usuario.
+ *
+ * @param mode - El modo de teams actual
+ * @param options - Las opciones de configuracion de teams
+ * @param userOwnedTeamsCount - Cuantos teams posee el usuario como owner
+ * @returns true si el usuario puede crear un nuevo team
+ *
+ * Logica:
+ * - single-user: NUNCA puede crear teams
+ * - single-tenant: NUNCA puede crear teams
+ * - multi-tenant + allowCreateTeams=true (default): SIEMPRE puede crear
+ * - multi-tenant + allowCreateTeams=false: Solo si userOwnedTeamsCount === 0
+ *
+ * @example
+ * ```typescript
+ * canUserCreateTeam('single-user', {}, 0)                              // false
+ * canUserCreateTeam('single-tenant', {}, 0)                            // false
+ * canUserCreateTeam('multi-tenant', {}, 0)                             // true
+ * canUserCreateTeam('multi-tenant', { allowCreateTeams: true }, 5)     // true
+ * canUserCreateTeam('multi-tenant', { allowCreateTeams: false }, 0)    // true (first team)
+ * canUserCreateTeam('multi-tenant', { allowCreateTeams: false }, 1)    // false (already has 1)
+ * ```
+ */
+export declare function canUserCreateTeam(mode: TeamsMode, options: TeamsConfigOptions, userOwnedTeamsCount: number): boolean;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/teams/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/teams/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEvD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEvD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAE5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,kBAAkB,EAC3B,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAgBT"}

package/dist/lib/teams/permissions.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Teams Core System - Permission System
+ *
+ * Defines permissions matrix and permission checking logic for teams.
+ *
+ * Phase 2 Simplification:
+ * - Global roles: only 'member' and 'superadmin' (5 → 2)
+ * - Team roles: unchanged (owner, admin, member, viewer)
+ * - Superadmin bypasses all team permissions
+ * - Member permissions determined by team role only
+ *
+ * Phase 5 Dynamic System:
+ * - Permissions, hierarchy, and invitable roles read from merged config
+ * - Themes can add custom roles via app.config.ts
+ * - No need to edit this file when adding new roles
+ *
+ * Phase 6 Unified Permissions:
+ * - All team permissions now read from permissions-registry
+ * - Single source of truth: permissions.config.ts
+ * - Uses TEAM_PERMISSIONS_BY_ROLE for O(1) lookups
+ */
+/**
+ * Global user roles (simplified Phase 2)
+ */
+export type UserRole = 'member' | 'superadmin';
+/**
+ * Team-specific permissions
+ */
+export type TeamPermission = 'team.view' | 'team.edit' | 'team.delete' | 'team.members.view' | 'team.members.invite' | 'team.members.remove' | 'team.members.update_role' | 'team.settings.view' | 'team.settings.edit' | 'team.billing.view' | 'team.billing.manage';
+/**
+ * All available team permissions
+ * Used for visualization and validation
+ */
+export declare const ALL_TEAM_PERMISSIONS: TeamPermission[];
+/**
+ * Permissions matrix by team role
+ *
+ * This export reads from permissions-registry, the single source of truth.
+ * Used by visualization components like RolesPermissionsMatrix.
+ *
+ * Note: For permission checking, use hasPermission() or checkTeamPermission()
+ */
+export declare const rolePermissions: Record<string, TeamPermission[]>;
+/**
+ * Check if a team role has a specific permission
+ *
+ * @param role - The team role to check (supports custom roles)
+ * @param permission - The permission to check for
+ * @param isGlobalAdmin - Whether the user is a global admin (bypasses team permissions)
+ * @returns True if the role has the permission, false otherwise
+ */
+export declare function hasPermission(role: string, permission: TeamPermission, isGlobalAdmin?: boolean): boolean;
+/**
+ * Get all permissions for a team role
+ *
+ * @param role - The team role (supports custom roles)
+ * @param isGlobalAdmin - Whether the user is a global admin
+ * @returns Array of permissions for the role
+ */
+export declare function getRolePermissions(role: string, isGlobalAdmin?: boolean): TeamPermission[];
+/**
+ * Check team permission with simplified Phase 2 roles
+ *
+ * This is the recommended function for permission checking.
+ * - Superadmin: bypasses all permissions (returns true)
+ * - Member: checks team role for permission
+ *
+ * @param userRole - The user's global role ('member' or 'superadmin')
+ * @param teamRole - The user's role in the team (null if not a member)
+ * @param permission - The permission to check
+ * @returns True if the user has the permission
+ */
+export declare function checkTeamPermission(userRole: UserRole, teamRole: string | null, permission: TeamPermission): boolean;
+/**
+ * Check if user is superadmin
+ *
+ * @param userRole - The user's global role
+ * @returns True if user is superadmin
+ */
+export declare function isSuperadmin(userRole: UserRole): boolean;
+/**
+ * Check if a role can perform an action on another role
+ * Used for member management (e.g., can admin remove owner?)
+ *
+ * Now reads hierarchy from merged config, supporting custom roles.
+ *
+ * @param actorRole - The role of the user performing the action
+ * @param targetRole - The role of the user being acted upon
+ * @returns True if action is allowed, false otherwise
+ */
+export declare function canManageRole(actorRole: string, targetRole: string): boolean;
+/**
+ * Get human-readable role description
+ *
+ * Reads from merged config, supporting custom role descriptions.
+ *
+ * @param role - The team role
+ * @returns Description of the role
+ */
+export declare function getRoleDescription(role: string): string;
+/**
+ * Check if a role can be assigned via invitation
+ * (e.g., can't invite someone as owner)
+ *
+ * @param role - The role to check
+ * @returns True if the role can be assigned via invitation
+ */
+export declare function isInvitableRole(role: string): boolean;
+/**
+ * Get available roles for invitation
+ * Returns all roles except owner, read from merged config.
+ *
+ * Now supports custom roles added by themes.
+ */
+export declare function getInvitableRoles(): string[];
+/**
+ * Validate role transition
+ * Check if changing from one role to another is allowed
+ *
+ * @param fromRole - Current role
+ * @param toRole - New role
+ * @param actorRole - Role of user making the change
+ * @returns Object with { allowed: boolean, reason?: string }
+ */
+export declare function validateRoleTransition(fromRole: string, toRole: string, actorRole: string): {
+    allowed: boolean;
+    reason?: string;
+};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/lib/teams/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../src/lib/teams/permissions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAUH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,WAAW,GACX,WAAW,GACX,aAAa,GACb,mBAAmB,GACnB,qBAAqB,GACrB,qBAAqB,GACrB,0BAA0B,GAC1B,oBAAoB,GACpB,oBAAoB,GACpB,mBAAmB,GACnB,qBAAqB,CAAA;AAEzB;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,EAYhD,CAAA;AAuCD;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAgC,CAAA;AAM7F;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,cAAc,EAC1B,aAAa,GAAE,OAAe,GAC7B,OAAO,CAWT;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,OAAe,GAC7B,cAAc,EAAE,CAQlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,UAAU,EAAE,cAAc,GACzB,OAAO,CAcT;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAExD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAKT;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGvD;AAMD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAI5C;AAMD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CA0BvC"}