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

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

@@ -0,0 +1,184 @@
+import type { EntityActionResult, EntityActionVoidResult, CreateEntityInput, UpdateEntityInput, ListEntityOptions, ListEntityResult, ActionConfig, BatchDeleteResult } from './types';
+/**
+ * Create a new entity record
+ *
+ * Auth is automatically obtained from session/cookies - no need to pass userId/teamId.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * @param entitySlug - The entity type slug (e.g., 'campaigns', 'schools')
+ * @param data - The entity data to create
+ * @param config - Optional configuration for revalidation/redirect
+ * @returns The created entity wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await createEntity('schools', {
+ *   name: 'MIT',
+ *   status: 'active'
+ * })
+ *
+ * if (result.success) {
+ *   console.log('Created:', result.data)
+ * } else {
+ *   console.error('Error:', result.error)
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom revalidation
+ * const result = await createEntity('campaigns', data, {
+ *   revalidatePaths: ['/dashboard/overview'],
+ *   revalidateTags: ['campaign-stats'],
+ * })
+ * ```
+ */
+export declare function createEntity<T = unknown>(entitySlug: string, data: CreateEntityInput, config?: ActionConfig): Promise<EntityActionResult<T>>;
+/**
+ * Update an existing entity record
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * @param entitySlug - The entity type slug
+ * @param id - The entity ID to update
+ * @param data - The fields to update
+ * @param config - Optional configuration for revalidation/redirect
+ * @returns The updated entity wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateEntity('campaigns', 'abc123', {
+ *   status: 'paused'
+ * })
+ * ```
+ */
+export declare function updateEntity<T = unknown>(entitySlug: string, id: string, data: UpdateEntityInput, config?: ActionConfig): Promise<EntityActionResult<T>>;
+/**
+ * Delete an entity record
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * @param entitySlug - The entity type slug
+ * @param id - The entity ID to delete
+ * @param config - Optional configuration for revalidation/redirect
+ * @returns Success status
+ *
+ * @example
+ * ```typescript
+ * await deleteEntity('leads', 'xyz789', {
+ *   redirectTo: '/dashboard/leads'
+ * })
+ * ```
+ */
+export declare function deleteEntity(entitySlug: string, id: string, config?: ActionConfig): Promise<EntityActionVoidResult>;
+/**
+ * Get a single entity by ID
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * Note: Prefer using Server Components for reads when possible.
+ * Use this action only when you need to fetch data from a Client Component.
+ *
+ * @param entitySlug - The entity type slug
+ * @param id - The entity ID
+ * @returns The entity or null
+ *
+ * @example
+ * ```typescript
+ * const result = await getEntity('campaigns', 'abc123')
+ * if (result.success && result.data) {
+ *   console.log('Found:', result.data)
+ * }
+ * ```
+ */
+export declare function getEntity<T = unknown>(entitySlug: string, id: string): Promise<EntityActionResult<T | null>>;
+/**
+ * List entities with filtering and pagination
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * Note: Prefer using Server Components for reads when possible.
+ * Use this action only when you need to fetch data from a Client Component.
+ *
+ * @param entitySlug - The entity type slug
+ * @param options - Filtering, sorting, pagination options
+ * @returns Paginated list of entities
+ *
+ * @example
+ * ```typescript
+ * const result = await listEntities('schools', {
+ *   where: { status: 'active' },
+ *   orderBy: 'name',
+ *   limit: 20
+ * })
+ *
+ * if (result.success) {
+ *   console.log(`Found ${result.data.total} schools`)
+ * }
+ * ```
+ */
+export declare function listEntities<T = unknown>(entitySlug: string, options?: ListEntityOptions): Promise<EntityActionResult<ListEntityResult<T>>>;
+/**
+ * Delete multiple entities at once
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ * Uses efficient batch delete (single query) by default.
+ *
+ * @param entitySlug - The entity type slug
+ * @param ids - Array of entity IDs to delete
+ * @param config - Optional configuration for revalidation/redirect
+ * @returns Count of deleted entities
+ *
+ * @example
+ * ```typescript
+ * const result = await deleteEntities('leads', ['id1', 'id2', 'id3'])
+ * if (result.success) {
+ *   console.log(`Deleted ${result.data.deletedCount} leads`)
+ * }
+ * ```
+ */
+export declare function deleteEntities(entitySlug: string, ids: string[], config?: ActionConfig): Promise<EntityActionResult<BatchDeleteResult>>;
+/**
+ * Check if an entity exists
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * @param entitySlug - The entity type slug
+ * @param id - The entity ID
+ * @returns Whether the entity exists and is accessible
+ *
+ * @example
+ * ```typescript
+ * const result = await entityExists('campaigns', 'abc123')
+ * if (result.success && result.data) {
+ *   console.log('Entity exists')
+ * }
+ * ```
+ */
+export declare function entityExists(entitySlug: string, id: string): Promise<EntityActionResult<boolean>>;
+/**
+ * Count entities with optional filtering
+ *
+ * Auth is automatically obtained from session/cookies.
+ * Permissions are checked against the permissions registry before executing.
+ *
+ * @param entitySlug - The entity type slug
+ * @param where - Filter conditions
+ * @returns Count of matching entities
+ *
+ * @example
+ * ```typescript
+ * const result = await countEntities('campaigns', { status: 'active' })
+ * if (result.success) {
+ *   console.log(`Found ${result.data} active campaigns`)
+ * }
+ * ```
+ */
+export declare function countEntities(entitySlug: string, where?: Record<string, unknown>): Promise<EntityActionResult<number>>;
+//# sourceMappingURL=entity.actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity.actions.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/entity.actions.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EAElB,MAAM,SAAS,CAAA;AAqChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5C,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,iBAAiB,EACvB,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAwDhC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5C,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,iBAAiB,EACvB,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CA+DhC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,sBAAsB,CAAC,CA4DjC;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,SAAS,CAAC,CAAC,GAAG,OAAO,EACzC,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,kBAAkB,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAsCvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5C,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAoClD;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EAAE,EACb,MAAM,CAAC,EAAE,YAAY,GACpB,OAAO,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,CA0DhD;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAuCtC;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,MAAM,EAClB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAkCrC"}

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

@@ -0,0 +1,52 @@
+/**
+ * NextSpark Server Actions
+ *
+ * Server Actions for CRUD operations, user management, and team management.
+ * Auth (userId/teamId) is obtained automatically from session and cookies.
+ *
+ * Import from '@nextsparkjs/core/actions' or '@nextsparkjs/core/lib/actions'.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   // Entity actions
+ *   createEntity,
+ *   updateEntity,
+ *   deleteEntity,
+ *   getEntity,
+ *   listEntities,
+ *   // User actions
+ *   updateProfile,
+ *   updateAvatar,
+ *   deleteAccount,
+ *   // Team actions
+ *   updateTeam,
+ *   inviteMember,
+ *   removeMember,
+ *   updateMemberRole,
+ * } from '@nextsparkjs/core/actions'
+ *
+ * // Entity operations - auth obtained from server session
+ * const result = await createEntity('schools', { name: 'MIT' })
+ * await updateEntity('campaigns', id, { status: 'paused' })
+ * await deleteEntity('leads', id, { redirectTo: '/leads' })
+ *
+ * // User profile operations
+ * await updateProfile({ firstName: 'John', lastName: 'Doe' })
+ * await updateAvatar(formData)
+ * await deleteAccount()
+ *
+ * // Team operations
+ * await updateTeam('team-id', { name: 'New Name' })
+ * await inviteMember('team-id', 'user@example.com', 'member')
+ * await removeMember('team-id', 'member-id')
+ * await updateMemberRole('team-id', 'member-id', 'admin')
+ * ```
+ */
+export { createEntity, updateEntity, deleteEntity, getEntity, listEntities, deleteEntities, entityExists, countEntities, } from './entity.actions';
+export { updateProfile, updateAvatar, deleteAccount, } from './user.actions';
+export type { UpdateProfileData, ProfileUpdateResult, } from './user.actions';
+export { updateTeam, inviteMember, removeMember, updateMemberRole, } from './team.actions';
+export type { UpdateTeamData, InviteMemberResult, } from './team.actions';
+export type { EntityActionResult, EntityActionVoidResult, CreateEntityInput, UpdateEntityInput, ListEntityOptions, ListEntityResult, ActionConfig, ActionAuthContext, BatchDeleteResult, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAMH,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,aAAa,GACd,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EACL,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,gBAAgB,CAAA;AAMvB,OAAO,EACL,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AAMvB,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,SAAS,CAAA"}

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

@@ -0,0 +1,107 @@
+import type { Team, TeamRole, TeamMember } from '../teams/types';
+import type { EntityActionResult, EntityActionVoidResult } from './types';
+/**
+ * Team update data that can be passed to updateTeam
+ */
+export interface UpdateTeamData {
+    name?: string;
+    slug?: string;
+    description?: string;
+    avatarUrl?: string;
+    settings?: Record<string, unknown>;
+}
+/**
+ * Result of invite member action
+ */
+export interface InviteMemberResult {
+    memberId: string;
+    userId: string;
+    teamId: string;
+    role: TeamRole;
+}
+/**
+ * Update a team's information
+ *
+ * Requires owner or admin role in the team.
+ *
+ * @param teamId - The team ID to update
+ * @param data - Team fields to update
+ * @returns Updated team data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateTeam('team-123', {
+ *   name: 'New Team Name',
+ *   description: 'Updated description'
+ * })
+ *
+ * if (result.success) {
+ *   console.log('Team updated:', result.data.name)
+ * }
+ * ```
+ */
+export declare function updateTeam(teamId: string, data: UpdateTeamData): Promise<EntityActionResult<Team>>;
+/**
+ * Invite a user to join the team
+ *
+ * Requires owner or admin role in the team.
+ * The user must already exist in the system.
+ *
+ * @param teamId - The team ID
+ * @param email - Email of the user to invite
+ * @param role - Role to assign (member, admin, viewer)
+ * @returns Created membership data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await inviteMember('team-123', 'user@example.com', 'member')
+ *
+ * if (result.success) {
+ *   console.log('Member invited:', result.data.memberId)
+ * }
+ * ```
+ */
+export declare function inviteMember(teamId: string, email: string, role?: TeamRole): Promise<EntityActionResult<InviteMemberResult>>;
+/**
+ * Remove a member from the team
+ *
+ * Requires owner or admin role in the team.
+ * Cannot remove the team owner (must transfer ownership first).
+ *
+ * @param teamId - The team ID
+ * @param memberId - The member ID to remove (from team_members table)
+ * @returns Success status
+ *
+ * @example
+ * ```typescript
+ * const result = await removeMember('team-123', 'member-id-456')
+ *
+ * if (result.success) {
+ *   console.log('Member removed')
+ * }
+ * ```
+ */
+export declare function removeMember(teamId: string, memberId: string): Promise<EntityActionVoidResult>;
+/**
+ * Update a team member's role
+ *
+ * Requires owner role to change to/from admin.
+ * Admins can change member/viewer roles.
+ * Cannot change owner role (must transfer ownership).
+ *
+ * @param teamId - The team ID
+ * @param memberId - The member's user ID
+ * @param role - New role to assign
+ * @returns Updated membership data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateMemberRole('team-123', 'user-456', 'admin')
+ *
+ * if (result.success) {
+ *   console.log('Role updated:', result.data.role)
+ * }
+ * ```
+ */
+export declare function updateMemberRole(teamId: string, memberId: string, role: TeamRole): Promise<EntityActionResult<TeamMember>>;
+//# sourceMappingURL=team.actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"team.actions.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/team.actions.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAMzE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;CACf;AAgDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CA4DnC;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,QAAmB,GACxB,OAAO,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAqEjD;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,CAAC,CAgEjC;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAsEzC"}

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

@@ -0,0 +1,98 @@
+/**
+ * Types for Entity Server Actions
+ *
+ * These types define the interface for generic CRUD operations
+ * via Server Actions in NextSpark.
+ */
+/**
+ * Result wrapper for all entity actions
+ * Discriminated union for type-safe success/error handling
+ */
+export type EntityActionResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Result wrapper for void actions (delete, etc.)
+ */
+export type EntityActionVoidResult = {
+    success: true;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Input type for creating entities
+ */
+export type CreateEntityInput = Record<string, unknown>;
+/**
+ * Input type for updating entities
+ */
+export type UpdateEntityInput = Record<string, unknown>;
+/**
+ * Options for listing entities
+ */
+export interface ListEntityOptions {
+    /** Filter conditions */
+    where?: Record<string, unknown>;
+    /** Field to sort by */
+    orderBy?: string;
+    /** Sort direction */
+    orderDir?: 'asc' | 'desc';
+    /** Number of records to return */
+    limit?: number;
+    /** Number of records to skip */
+    offset?: number;
+    /** Text search query */
+    search?: string;
+}
+/**
+ * Result of listing entities
+ */
+export interface ListEntityResult<T> {
+    /** Array of entities */
+    data: T[];
+    /** Total count (for pagination) */
+    total: number;
+    /** Current limit */
+    limit: number;
+    /** Current offset */
+    offset: number;
+}
+/**
+ * Configuration options for actions
+ * Controls revalidation and redirection behavior
+ */
+export interface ActionConfig {
+    /** Paths to revalidate after mutation (uses revalidatePath) */
+    revalidatePaths?: string[];
+    /** Tags to revalidate after mutation (uses revalidateTag) */
+    revalidateTags?: string[];
+    /**
+     * Redirect after successful mutation.
+     * WARNING: Uses Next.js redirect() which throws NEXT_REDIRECT.
+     * When redirectTo is set, the action will NOT return data - it redirects instead.
+     */
+    redirectTo?: string;
+}
+/**
+ * Authentication context for actions
+ * Contains user and team information
+ */
+export interface ActionAuthContext {
+    /** Current user ID */
+    userId: string;
+    /** Current team ID */
+    teamId: string;
+}
+/**
+ * Result of batch delete operation
+ */
+export interface BatchDeleteResult {
+    /** Number of entities deleted */
+    deletedCount: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAC5B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAC1B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErC;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GACjB;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAMrC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEvD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAMvD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,wBAAwB;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,uBAAuB;IACvB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qBAAqB;IACrB,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACzB,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,wBAAwB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,wBAAwB;IACxB,IAAI,EAAE,CAAC,EAAE,CAAA;IACT,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAA;CACf;AAMD;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAMD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;CACf;AAMD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,YAAY,EAAE,MAAM,CAAA;CACrB"}

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

@@ -0,0 +1,99 @@
+import type { EntityActionResult, EntityActionVoidResult } from './types';
+/**
+ * Profile update data that can be passed to updateProfile
+ */
+export interface UpdateProfileData {
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+}
+/**
+ * Result of profile update with user data
+ */
+export interface ProfileUpdateResult {
+    id: string;
+    email: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    image?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+}
+/**
+ * Update the current user's profile information
+ *
+ * Auth is automatically obtained from session - users can only update their own profile.
+ *
+ * @param data - Profile fields to update
+ * @returns Updated user data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateProfile({
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   timezone: 'America/New_York'
+ * })
+ *
+ * if (result.success) {
+ *   console.log('Profile updated:', result.data)
+ * } else {
+ *   console.error('Error:', result.error)
+ * }
+ * ```
+ */
+export declare function updateProfile(data: UpdateProfileData): Promise<EntityActionResult<ProfileUpdateResult>>;
+/**
+ * Update the current user's avatar image
+ *
+ * Accepts FormData with an 'avatar' or 'image' field containing the image URL or file path.
+ * For actual file uploads, the file should be uploaded to storage first and the URL passed here.
+ *
+ * @param formData - FormData with 'avatar' or 'image' field containing the image URL
+ * @returns Updated user data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * // After uploading file to storage
+ * const formData = new FormData()
+ * formData.append('avatar', imageUrl)
+ * const result = await updateAvatar(formData)
+ *
+ * if (result.success) {
+ *   console.log('Avatar updated:', result.data.image)
+ * }
+ * ```
+ */
+export declare function updateAvatar(formData: FormData): Promise<EntityActionResult<ProfileUpdateResult>>;
+/**
+ * Delete the current user's account
+ *
+ * This is a destructive operation that:
+ * - Removes the user from all teams
+ * - Deletes user metadata
+ * - Deletes the user account
+ *
+ * Teams owned by the user must have ownership transferred first or be deleted.
+ *
+ * @returns Success status
+ *
+ * @example
+ * ```typescript
+ * // Show confirmation dialog first!
+ * const confirmed = window.confirm('Are you sure? This cannot be undone.')
+ * if (confirmed) {
+ *   const result = await deleteAccount()
+ *   if (result.success) {
+ *     // Redirect to goodbye page or login
+ *     router.push('/goodbye')
+ *   }
+ * }
+ * ```
+ */
+export declare function deleteAccount(): Promise<EntityActionVoidResult>;
+//# sourceMappingURL=user.actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user.actions.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/user.actions.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAMzE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC,CA2DlD;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC,CAsElD;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAsDrE"}

package/dist/lib/api/auth/devtools-auth.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DevTools API Authentication
+ *
+ * Permission helpers for devtools-only API endpoints.
+ * Only superadmin and developer user roles can access these APIs.
+ */
+import { NextResponse } from 'next/server';
+import type { DualAuthResult } from './dual-auth';
+/**
+ * Check if the authenticated user can access DevTools APIs
+ *
+ * @param authResult - Result from authenticateRequest()
+ * @returns true if user has superadmin or developer role
+ */
+export declare function canAccessDevtoolsApi(authResult: DualAuthResult): boolean;
+/**
+ * Create a standardized 403 Forbidden response for DevTools API access denial
+ */
+export declare function createDevtoolsAccessDeniedResponse(): NextResponse;
+/**
+ * Create a standardized 401 Unauthorized response
+ */
+export declare function createDevtoolsUnauthorizedResponse(): NextResponse;
+//# sourceMappingURL=devtools-auth.d.ts.map

package/dist/lib/api/auth/devtools-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools-auth.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/auth/devtools-auth.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AASjD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAQxE;AAED;;GAEG;AACH,wBAAgB,kCAAkC,IAAI,YAAY,CAejE;AAED;;GAEG;AACH,wBAAgB,kCAAkC,IAAI,YAAY,CAcjE"}

package/dist/lib/api/auth/dual-auth.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Dual Authentication System
+ *
+ * Supports both API Key and Session authentication in a single endpoint.
+ * Used by the unified /api/v1/ endpoints.
+ */
+import { NextRequest } from 'next/server';
+/**
+ * System Admin Team - Members can bypass team context validation
+ * This team is created in core/migrations/090_sample_data.sql
+ */
+export declare const SYSTEM_ADMIN_TEAM_ID = "team-nextspark-001";
+/**
+ * Header required to confirm cross-team access intention
+ */
+export declare const ADMIN_BYPASS_HEADER = "x-admin-bypass";
+export declare const ADMIN_BYPASS_VALUE = "confirm-cross-team-access";
+export interface DualAuthUser {
+    id: string;
+    email: string;
+    role: string;
+    name?: string;
+    defaultTeamId?: string;
+}
+export interface DualAuthResult {
+    success: boolean;
+    type: 'api-key' | 'session' | 'none';
+    user: DualAuthUser | null;
+    scopes?: string[];
+    rateLimitResponse?: Response;
+}
+/**
+ * Try to authenticate request using either API Key or Session
+ */
+export declare function authenticateRequest(request: NextRequest): Promise<DualAuthResult>;
+/**
+ * Check if user has required scope (for API Key auth)
+ */
+export declare function hasRequiredScope(authResult: DualAuthResult, requiredScope: string): boolean;
+/**
+ * Check if user can bypass team context validation
+ *
+ * Three-layer security model:
+ * 1. User must have elevated role (superadmin/developer)
+ * 2. Request must include confirmation header (x-admin-bypass)
+ * 3. User must be member of System Admin Team (NextSpark Team)
+ *
+ * @returns true if all conditions are met
+ */
+export declare function canBypassTeamContext(authResult: DualAuthResult, request: NextRequest): Promise<boolean>;
+/**
+ * Create standardized auth error response
+ */
+export declare function createAuthError(message?: string, status?: number): Response;
+//# sourceMappingURL=dual-auth.d.ts.map

package/dist/lib/api/auth/dual-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-auth.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/auth/dual-auth.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAQzC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,uBAAuB,CAAA;AAExD;;GAEG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAA;AACnD,eAAO,MAAM,kBAAkB,8BAA8B,CAAA;AAO7D,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAA;IACpC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,iBAAiB,CAAC,EAAE,QAAQ,CAAA;CAC7B;AAqBD;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAkBvF;AAqFD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAY3F;AAMD;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CAkBlB;AAkBD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,MAAkC,EAAE,MAAM,GAAE,MAAY,YAchG"}

package/dist/lib/api/auth/permissions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Admin Permission Helpers
+ *
+ * Centralized permission validation for admin-only endpoints.
+ * Supports both API Key and Session authentication.
+ */
+import type { DualAuthResult } from './dual-auth';
+/**
+ * Verifica si el usuario autenticado es superadmin
+ * Funciona tanto para sesiones como para API keys
+ *
+ * @param authResult - Resultado de autenticacion dual
+ * @returns true si el usuario es superadmin
+ */
+export declare function isSuperAdmin(authResult: DualAuthResult): boolean;
+/**
+ * Verifica si el usuario tiene permisos para operaciones administrativas
+ * Combina validacion de superadmin + scopes de API key
+ *
+ * @param authResult - Resultado de autenticacion
+ * @param requiredScope - Scope requerido para API keys (opcional)
+ * @returns true si tiene permisos de admin
+ */
+export declare function hasAdminPermission(authResult: DualAuthResult, requiredScope?: string): boolean;
+//# sourceMappingURL=permissions.d.ts.map