@pol-studios/db 1.0.19 → 1.0.21

package/dist/auth/hooks.d.ts

@@ -0,0 +1,312 @@
+import { User } from '@supabase/supabase-js';
+import { a as SetupAuthContext } from '../setupAuthContext-Kv-THH-h.js';
+import { d as EntityType, a as EntityAction, b as EntityPermissionCheck } from '../EntityPermissions-DwFt4tUd.js';
+export { u as useSetUserMetadata, a as useUserMetadata, b as useUserMetadataState, c as useUserMetadataValue } from '../UserMetadataContext-DntmpK41.js';
+import 'react/jsx-runtime';
+import 'react';
+import '../useSupabase-DvWVuHHE.js';
+import '@supabase/supabase-js/dist/module/lib/types.js';
+
+/**
+ * Hook for authenticated users only.
+ * Throws an error if the user is not authenticated.
+ * Use useSetupAuth() if you need to handle unauthenticated users.
+ *
+ * @returns Auth context with guaranteed non-null user and hasAccess helper
+ * @throws Error if user is not authenticated
+ *
+ * @example
+ * ```tsx
+ * function AuthenticatedComponent() {
+ *   const { user, hasAccess, profile } = useAuth();
+ *
+ *   // user is guaranteed to be non-null
+ *   console.log(user.id);
+ *
+ *   if (hasAccess('admin')) {
+ *     return <AdminDashboard />;
+ *   }
+ *
+ *   return <UserDashboard />;
+ * }
+ * ```
+ */
+declare function useAuth(): Omit<SetupAuthContext, "user"> & {
+    hasAccess: (access: string) => boolean;
+    user: User;
+};
+/**
+ * Hook for handling both authenticated and unauthenticated states.
+ * Does not throw if user is not authenticated.
+ *
+ * @returns Auth context with possibly null user, hasAccess, and hasEntityAccess helpers
+ *
+ * @example
+ * ```tsx
+ * function FlexibleComponent() {
+ *   const { user, hasAccess, hasEntityAccess, isLoading } = useSetupAuth();
+ *
+ *   if (isLoading) {
+ *     return <Spinner />;
+ *   }
+ *
+ *   if (!user) {
+ *     return <LoginPrompt />;
+ *   }
+ *
+ *   // Check global access
+ *   const isAdmin = hasAccess('admin');
+ *
+ *   // Check entity-level access
+ *   const canEditProject = hasEntityAccess('Project', 123, 'edit');
+ *
+ *   return <Dashboard />;
+ * }
+ * ```
+ */
+declare function useSetupAuth(): SetupAuthContext & {
+    hasAccess: (access: string) => boolean;
+    hasEntityAccess: (entityType: EntityType, entityId: number, action: EntityAction) => boolean;
+};
+
+/**
+ * Hook to get full permission info for a single entity
+ * @param entityType - 'Project' | 'Client' | 'ProjectDatabase'
+ * @param entityId - The ID of the entity (can be undefined for loading states)
+ * @returns EntityPermissionCheck with canView, canEdit, etc. and isLoading
+ *
+ * @example
+ * ```tsx
+ * function ProjectHeader({ projectId }: { projectId: number }) {
+ *   const permission = usePermission('Project', projectId);
+ *
+ *   if (permission.isLoading) {
+ *     return <Spinner />;
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {permission.canEdit && <EditButton />}
+ *       {permission.canDelete && <DeleteButton />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePermission(entityType: EntityType, entityId: number | undefined): EntityPermissionCheck;
+/**
+ * Hook to check a single action permission
+ * @param entityType - Entity type
+ * @param entityId - Entity ID
+ * @param action - 'view' | 'adminView' | 'edit' | 'create' | 'delete' | 'share'
+ * @returns boolean - true if user has permission for action
+ *
+ * @example
+ * ```tsx
+ * function ProjectActions({ projectId }: { projectId: number }) {
+ *   const canEdit = usePermissionCheck('Project', projectId, 'edit');
+ *   const canDelete = usePermissionCheck('Project', projectId, 'delete');
+ *
+ *   return (
+ *     <div>
+ *       <Button disabled={!canEdit}>Edit</Button>
+ *       <Button disabled={!canDelete}>Delete</Button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePermissionCheck(entityType: EntityType, entityId: number | undefined, action: EntityAction): boolean;
+/**
+ * Result type for usePermissions batch hook
+ */
+interface EntityWithPermission {
+    type: EntityType;
+    id: number;
+    permission: EntityPermissionCheck;
+}
+/**
+ * Hook for batch permission lookup - useful for lists
+ * @param entities - Array of { type, id } objects
+ * @returns Array of entities with their permissions attached
+ *
+ * This hook:
+ * - Calls prefetchPermissions on mount and when entities change
+ * - Returns memoized results
+ * - Handles empty arrays gracefully
+ *
+ * @example
+ * ```tsx
+ * function ProjectList({ projects }: { projects: Array<{ id: number; name: string }> }) {
+ *   const entities = projects.map(p => ({ type: 'Project' as const, id: p.id }));
+ *   const entitiesWithPermissions = usePermissionsBatch(entities);
+ *
+ *   return (
+ *     <ul>
+ *       {entitiesWithPermissions.map(({ id, permission }) => {
+ *         const project = projects.find(p => p.id === id);
+ *         return (
+ *           <li key={id}>
+ *             {project?.name}
+ *             {permission.canEdit && <EditIcon />}
+ *           </li>
+ *         );
+ *       })}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function usePermissionsBatch(entities: Array<{
+    type: EntityType;
+    id: number;
+}>): EntityWithPermission[];
+/**
+ * Simple boolean hook to check if user can view an entity
+ * @param entityType - Entity type
+ * @param entityId - Entity ID (can be undefined for loading states)
+ * @returns boolean - true if user can view the entity
+ *
+ * @example
+ * ```tsx
+ * function ProjectPage({ projectId }: { projectId: number }) {
+ *   const canView = useCanView('Project', projectId);
+ *
+ *   if (!canView) {
+ *     return <AccessDenied />;
+ *   }
+ *
+ *   return <ProjectContent projectId={projectId} />;
+ * }
+ * ```
+ */
+declare function useCanView(entityType: EntityType, entityId: number | undefined): boolean;
+/**
+ * Simple boolean hook to check if user can edit an entity
+ * @param entityType - Entity type
+ * @param entityId - Entity ID (can be undefined for loading states)
+ * @returns boolean - true if user can edit the entity
+ *
+ * @example
+ * ```tsx
+ * function ProjectEditor({ projectId }: { projectId: number }) {
+ *   const canEdit = useCanEdit('Project', projectId);
+ *
+ *   return (
+ *     <form>
+ *       <input disabled={!canEdit} />
+ *       <button disabled={!canEdit}>Save</button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+declare function useCanEdit(entityType: EntityType, entityId: number | undefined): boolean;
+/**
+ * Simple boolean hook to check if user can delete an entity
+ * @param entityType - Entity type
+ * @param entityId - Entity ID (can be undefined for loading states)
+ * @returns boolean - true if user can delete the entity
+ *
+ * @example
+ * ```tsx
+ * function ProjectActions({ projectId }: { projectId: number }) {
+ *   const canDelete = useCanDelete('Project', projectId);
+ *
+ *   return (
+ *     <Button
+ *       variant="destructive"
+ *       disabled={!canDelete}
+ *       onClick={handleDelete}
+ *     >
+ *       Delete Project
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCanDelete(entityType: EntityType, entityId: number | undefined): boolean;
+/**
+ * Simple boolean hook to check if user can share an entity
+ * @param entityType - Entity type
+ * @param entityId - Entity ID (can be undefined for loading states)
+ * @returns boolean - true if user can share the entity
+ *
+ * @example
+ * ```tsx
+ * function ShareButton({ projectId }: { projectId: number }) {
+ *   const canShare = useCanShare('Project', projectId);
+ *
+ *   if (!canShare) {
+ *     return null;
+ *   }
+ *
+ *   return <Button onClick={openShareModal}>Share</Button>;
+ * }
+ * ```
+ */
+declare function useCanShare(entityType: EntityType, entityId: number | undefined): boolean;
+/**
+ * Simple boolean hook to check if user can create entities of a type
+ * Note: For create permission, the entityId should be the parent entity ID
+ * (e.g., for creating a ProjectDatabase, pass the Project ID)
+ *
+ * @param entityType - Entity type
+ * @param entityId - Parent entity ID (can be undefined for loading states)
+ * @returns boolean - true if user can create entities
+ *
+ * @example
+ * ```tsx
+ * function AddDatabaseButton({ projectId }: { projectId: number }) {
+ *   const canCreate = useCanCreate('ProjectDatabase', projectId);
+ *
+ *   return (
+ *     <Button disabled={!canCreate} onClick={handleCreate}>
+ *       Add Database
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCanCreate(entityType: EntityType, entityId: number | undefined): boolean;
+/**
+ * Hook to invalidate permission cache for a specific entity
+ * Useful after permission changes (e.g., after sharing an entity)
+ *
+ * @returns Function to invalidate permission for an entity
+ *
+ * @example
+ * ```tsx
+ * function ShareModal({ projectId }: { projectId: number }) {
+ *   const invalidatePermission = useInvalidatePermission();
+ *
+ *   const handleShare = async (userId: string) => {
+ *     await shareProject(projectId, userId);
+ *     invalidatePermission('Project', projectId);
+ *   };
+ *
+ *   return <ShareForm onShare={handleShare} />;
+ * }
+ * ```
+ */
+declare function useInvalidatePermission(): (entityType: EntityType, entityId: number) => void;
+/**
+ * Hook to get the loading state of the permission context
+ * @returns boolean - true if permissions are being fetched
+ *
+ * @example
+ * ```tsx
+ * function PermissionAwareComponent() {
+ *   const isLoadingPermissions = usePermissionLoading();
+ *
+ *   if (isLoadingPermissions) {
+ *     return <LoadingSpinner />;
+ *   }
+ *
+ *   return <Content />;
+ * }
+ * ```
+ */
+declare function usePermissionLoading(): boolean;
+
+export { EntityAction, EntityPermissionCheck, EntityType, type EntityWithPermission, useAuth, useCanCreate, useCanDelete, useCanEdit, useCanShare, useCanView, useInvalidatePermission, usePermission, usePermissionCheck, usePermissionLoading, usePermissionsBatch, useSetupAuth };

package/dist/auth/index.d.ts

@@ -0,0 +1,11 @@
+export { EntityWithPermission, useAuth, useCanCreate, useCanDelete, useCanEdit, useCanShare, useCanView, useInvalidatePermission, usePermission, usePermissionCheck, usePermissionLoading, usePermissionsBatch, useSetupAuth } from './hooks.js';
+export { c as Profile, P as ProfileStatus, a as SetupAuthContext, S as SetupAuthContextProvider, b as SetupAuthContextProviderProps, s as setupAuthContext } from '../setupAuthContext-Kv-THH-h.js';
+export { AuthProvider, AuthProviderProps, EntityPermissionContextValue, PermissionContextValue, PermissionProvider, entityPermissionContext, permissionContext, usePermissions } from './context.js';
+export { U as UserMetadataContextType, e as UserMetadataInsert, f as UserMetadataProvider, g as UserMetadataRow, h as UserMetadataUpdate, u as useSetUserMetadata, a as useUserMetadata, b as useUserMetadataState, c as useUserMetadataValue, d as userMetadataContext } from '../UserMetadataContext-DntmpK41.js';
+export { hasAccess, hasAllAccess, hasAllEntityAccess, hasAnyAccess, hasAnyEntityAccess, hasEntityAccess, isEntityAccessDenied, isPermissionLoaded } from './guards.js';
+export { E as EntityAccessRecord, a as EntityAction, b as EntityPermissionCheck, c as EntityPermissionLevel, d as EntityType, P as PermissionEffect } from '../EntityPermissions-DwFt4tUd.js';
+import '@supabase/supabase-js';
+import 'react/jsx-runtime';
+import 'react';
+import '../useSupabase-DvWVuHHE.js';
+import '@supabase/supabase-js/dist/module/lib/types.js';

package/dist/client/index.d.ts

@@ -0,0 +1,16 @@
+export { C as ClientInstanceId, D as Database, S as SupabaseDatabaseTypes, a as SupabaseProvider, T as TypedSupabaseClient, U as UserSessionId, c as createNewSupabaseClient, o as onSupabaseInitialized, s as setDefaultOptions, t as typedSupabase, u as useSupabase } from '../useSupabase-DvWVuHHE.js';
+import 'react/jsx-runtime';
+import '@supabase/supabase-js/dist/module/lib/types.js';
+import 'react';
+import '@supabase/supabase-js';
+
+declare function setSupabaseUrl(url: string): void;
+declare function getSupabaseUrl(): string;
+declare function setSupabaseKey(key: string): void;
+declare function getSupabaseKey(): string;
+
+declare function useFunction(): {
+    downloadFunctionResponse: (functionName: string, body?: any, name?: string) => Promise<void>;
+};
+
+export { getSupabaseKey, getSupabaseUrl, setSupabaseKey, setSupabaseUrl, useFunction };