@pol-studios/db 1.0.19 → 1.0.22

package/dist/EntityPermissions-DwFt4tUd.d.ts

@@ -0,0 +1,35 @@
+type EntityType = 'Project' | 'Client' | 'ProjectDatabase';
+type EntityPermissionLevel = 'ReadOnly' | 'AdminReadOnly' | 'ReadWrite' | 'Admin';
+type PermissionEffect = 'allow' | 'deny';
+type EntityAction = 'view' | 'adminView' | 'edit' | 'create' | 'delete' | 'share';
+interface EntityPermissionCheck {
+    canView: boolean;
+    canAdminView: boolean;
+    canEdit: boolean;
+    canCreate: boolean;
+    canDelete: boolean;
+    canShare: boolean;
+    permissionLevel: EntityPermissionLevel | null;
+    isLoading: boolean;
+    /** Whether access was explicitly denied */
+    isDenied?: boolean;
+}
+interface EntityAccessRecord {
+    id: number;
+    userId: string;
+    entityType: EntityType;
+    entityId: number;
+    permission: EntityPermissionLevel;
+    /** Permission effect - 'allow' grants access, 'deny' explicitly blocks */
+    effect: PermissionEffect;
+    inheritedFromClientId?: number | null;
+    inheritFromProject?: boolean;
+    /** User ID who granted this permission */
+    grantedBy?: string | null;
+    /** ISO timestamp when permission was granted */
+    grantedAt?: string;
+    /** ISO timestamp when permission expires, null for never */
+    expiresAt?: string | null;
+}
+
+export type { EntityAccessRecord as E, PermissionEffect as P, EntityAction as a, EntityPermissionCheck as b, EntityPermissionLevel as c, EntityType as d };

package/dist/FilterConfig-Bt2Ek74z.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Unified Filter Configuration Type
+ *
+ * This is the canonical type for filter configuration across the codebase.
+ * Replaces both ValueOption and SimpleFilterConfig.
+ */
+type PropertyType = "string" | "number" | "boolean" | "date";
+type ValueForPropertyType<T extends PropertyType> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "date" ? Date : never;
+interface TableInfo {
+    tableName: string;
+    schemaName?: string;
+    outputProperty?: string;
+    innerProperty: string;
+    innerCast?: string;
+}
+interface SortConfig {
+    isSortable?: boolean;
+    properties?: string[];
+}
+interface FilterConfigOption<PT extends PropertyType = PropertyType> {
+    display: string;
+    value: ValueForPropertyType<PT>;
+}
+/**
+ * Simple filter clause for WHERE conditions
+ * Used in edge function query building
+ */
+interface WhereFilter {
+    id: string;
+    field: string;
+    op: string;
+    value: string | number | string[] | number[] | boolean | null;
+    not?: boolean;
+}
+/**
+ * WhereClause can be either:
+ * - string: For edge function format like "tagId.eq.5"
+ * - WhereFilter: For complex filter objects
+ */
+type WhereClause = string | WhereFilter;
+/**
+ * Unified FilterConfig - the canonical filter configuration type
+ *
+ * Uses `field` with dot notation for relationships.
+ * Examples: "name", "locationId.name", "locationId.tags.value"
+ */
+interface FilterConfig<EntityType = unknown, PT extends PropertyType = PropertyType> {
+    /**
+     * Field path using dot notation for relationships
+     * Examples: "name", "locationId.name", "locationId.tags.value"
+     */
+    field?: string;
+    /** The property name on the entity */
+    property?: keyof EntityType | string;
+    /** Display label shown in UI */
+    display: string;
+    /**
+     * Data type of the field. Can be inferred from schema when using `field`.
+     */
+    propertyType?: PT;
+    /** Whether this field is searchable via text search (default: true for strings) */
+    searchable?: boolean;
+    /** Additional WHERE clause for relationship filtering */
+    where?: WhereClause;
+    /** Relationship configuration for many-to-one joins */
+    manyToOneTableInfo?: TableInfo & {
+        innerTable?: TableInfo[];
+    };
+    /** Predefined dropdown options */
+    options?: FilterConfigOption<PT>[];
+    /** Sort configuration for this field */
+    sortOptions?: SortConfig;
+    /** Mark as metadata field (custom columns) */
+    isMetadata?: boolean;
+    /** Hide behind "Show More Filters" button */
+    advanced?: boolean;
+    /** Show in "Recommended" section */
+    recommended?: boolean;
+    /** Custom render function for display in filter dropdown */
+    renderOption?: (option: FilterConfig<EntityType, PT>) => string;
+}
+/**
+ * Group of filter configs for organizing filters in UI
+ * Note: Named "Group" to avoid conflict with FilterGroup (AND/OR query groups)
+ */
+interface Group {
+    /** Title displayed for the group (used as 'label' in some contexts) */
+    title: string;
+    /** Optional nesting level for UI rendering */
+    level?: number;
+    /** Hide entire group by default behind "Show More Filters" button */
+    advanced?: boolean;
+    /** Show this group in the "Recommended" section at the top of the filter dropdown */
+    recommended?: boolean;
+    /** Child filter configs or nested groups */
+    children: (FilterConfig | Group)[];
+}
+
+export type { FilterConfigOption as F, Group as G, PropertyType as P, SortConfig as S, TableInfo as T, ValueForPropertyType as V, WhereFilter as W, FilterConfig as a, WhereClause as b };

package/dist/UserMetadataContext-B8gVWGMl.d.ts

@@ -0,0 +1,35 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { D as Database } from './useSupabase-DvWVuHHE.js';
+
+declare function useLiveChangesIndicator(value: any, field: string | undefined): [boolean, string];
+
+type UserMetadataRow = Database["core"]["Tables"]["UserMetadata"]["Row"];
+type UserMetadataInsert = Database["core"]["Tables"]["UserMetadata"]["Insert"];
+type UserMetadataUpdate = Database["core"]["Tables"]["UserMetadata"]["Update"];
+interface UserMetadataContextType {
+    metadata: Record<string, string>;
+    isLoading: boolean;
+    error: Error | null;
+    setMetadata: (key: string, value: string) => Promise<void>;
+    getMetadata: (key: string) => string | undefined;
+    removeMetadata: (key: string) => Promise<void>;
+    refreshMetadata: () => Promise<void>;
+}
+declare const userMetadataContext: react.Context<UserMetadataContextType>;
+declare function UserMetadataContextProvider({ children, }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useUserMetadata(): UserMetadataContextType;
+declare function useUserMetadataValue(key: string): string | undefined;
+declare function useSetUserMetadata(): {
+    setMetadata: (key: string, value: string) => Promise<void>;
+    removeMetadata: (key: string) => Promise<void>;
+};
+declare function useUserMetadataState<T>(key: string, defaultValue: T, options?: {
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+}): [T, (value: T) => Promise<void>, boolean];
+
+export { type UserMetadataRow as U, type UserMetadataInsert as a, type UserMetadataUpdate as b, type UserMetadataContextType as c, userMetadataContext as d, UserMetadataContextProvider as e, useUserMetadata as f, useUserMetadataValue as g, useSetUserMetadata as h, useUserMetadataState as i, useLiveChangesIndicator as u };

package/dist/UserMetadataContext-DntmpK41.d.ts

@@ -0,0 +1,33 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { D as Database } from './useSupabase-DvWVuHHE.js';
+
+type UserMetadataRow = Database["core"]["Tables"]["UserMetadata"]["Row"];
+type UserMetadataInsert = Database["core"]["Tables"]["UserMetadata"]["Insert"];
+type UserMetadataUpdate = Database["core"]["Tables"]["UserMetadata"]["Update"];
+interface UserMetadataContextType {
+    metadata: Record<string, string>;
+    isLoading: boolean;
+    error: Error | null;
+    setMetadata: (key: string, value: string) => Promise<void>;
+    getMetadata: (key: string) => string | undefined;
+    removeMetadata: (key: string) => Promise<void>;
+    refreshMetadata: () => Promise<void>;
+}
+declare const userMetadataContext: react.Context<UserMetadataContextType>;
+declare function UserMetadataProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useUserMetadata(): UserMetadataContextType;
+declare function useUserMetadataValue(key: string): string | undefined;
+declare function useSetUserMetadata(): {
+    setMetadata: (key: string, value: string) => Promise<void>;
+    removeMetadata: (key: string) => Promise<void>;
+};
+declare function useUserMetadataState<T>(key: string, defaultValue: T, options?: {
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+}): [T, (value: T) => Promise<void>, boolean];
+
+export { type UserMetadataContextType as U, useUserMetadata as a, useUserMetadataState as b, useUserMetadataValue as c, userMetadataContext as d, type UserMetadataInsert as e, UserMetadataProvider as f, type UserMetadataRow as g, type UserMetadataUpdate as h, useSetUserMetadata as u };

package/dist/auth/context.d.ts

@@ -0,0 +1,48 @@
+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';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { d as EntityType, b as EntityPermissionCheck, a as EntityAction } from '../EntityPermissions-DwFt4tUd.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';
+import '@supabase/supabase-js';
+import '../useSupabase-DvWVuHHE.js';
+import '@supabase/supabase-js/dist/module/lib/types.js';
+
+interface AuthProviderProps {
+    children: ReactNode;
+    /**
+     * Enable entity-level permissions system (Project, Client, ProjectDatabase access control).
+     * When enabled, wraps children with PermissionProvider.
+     * @default false
+     */
+    enableEntityPermissions?: boolean;
+}
+declare function AuthProvider({ children, enableEntityPermissions, }: AuthProviderProps): react_jsx_runtime.JSX.Element;
+
+interface EntityIdentifier {
+    entityType: EntityType;
+    entityId: number;
+}
+interface PermissionContextValue {
+    getPermission: (entityType: EntityType, entityId: number) => EntityPermissionCheck;
+    checkPermission: (entityType: EntityType, entityId: number, action: EntityAction) => boolean;
+    prefetchPermissions: (entities: EntityIdentifier[]) => Promise<void>;
+    invalidatePermission: (entityType: EntityType, entityId: number) => void;
+    isLoading: boolean;
+}
+/**
+ * @deprecated Use permissionContext instead
+ */
+interface EntityPermissionContextValue extends PermissionContextValue {
+}
+declare const permissionContext: react.Context<PermissionContextValue>;
+/**
+ * @deprecated Use permissionContext instead
+ */
+declare const entityPermissionContext: react.Context<PermissionContextValue>;
+declare function PermissionProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function usePermissions(): PermissionContextValue;
+
+export { AuthProvider, type AuthProviderProps, type EntityPermissionContextValue, type PermissionContextValue, PermissionProvider, entityPermissionContext, permissionContext, usePermissions };

package/dist/auth/context.js

@@ -12,8 +12,8 @@ import {
   useUserMetadataState,
   useUserMetadataValue,
   userMetadataContext
-} from "../chunk-72WV3ALS.js";
-import "../chunk-YERWPV6B.js";
+} from "../chunk-OUUQSI3Y.js";
+import "../chunk-3FHAKRDV.js";
 import "../chunk-GC3TBUWE.js";
 import "../chunk-J4ZVCXZ4.js";
 import "../chunk-OQ7U6EQ3.js";

package/dist/auth/guards.d.ts

@@ -0,0 +1,180 @@
+import { b as EntityPermissionCheck, a as EntityAction } from '../EntityPermissions-DwFt4tUd.js';
+
+/**
+ * Check if a user has access to a specific permission key.
+ * Owners bypass all permission checks.
+ *
+ * @param accessKeys - Array of access keys the user has
+ * @param key - The access key to check for
+ * @param options - Additional options for the check
+ * @param options.isArchived - Whether the user is archived
+ * @param options.isSuspended - Whether the user is suspended
+ * @returns boolean - true if user has the specified access
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const canAccess = hasAccess(['admin', 'viewer'], 'admin'); // true
+ * const cannotAccess = hasAccess(['viewer'], 'admin'); // false
+ *
+ * // Owner bypasses all checks
+ * const ownerAccess = hasAccess(['owner'], 'any-key'); // true
+ *
+ * // Empty key always returns true (no permission required)
+ * const noKeyRequired = hasAccess(['viewer'], ''); // true
+ *
+ * // Archived/suspended users have no access
+ * const archivedUser = hasAccess(['admin'], 'admin', { isArchived: true }); // false
+ * ```
+ */
+declare function hasAccess(accessKeys: string[] | undefined | null, key: string, options?: {
+    isArchived?: boolean;
+    isSuspended?: boolean;
+}): boolean;
+/**
+ * Check if a user has any of the specified access keys.
+ *
+ * @param accessKeys - Array of access keys the user has
+ * @param keys - Array of access keys to check for (OR logic)
+ * @param options - Additional options for the check
+ * @returns boolean - true if user has any of the specified keys
+ *
+ * @example
+ * ```ts
+ * const hasAny = hasAnyAccess(['viewer'], ['admin', 'editor', 'viewer']); // true
+ * const hasNone = hasAnyAccess(['viewer'], ['admin', 'editor']); // false
+ * ```
+ */
+declare function hasAnyAccess(accessKeys: string[] | undefined | null, keys: string[], options?: {
+    isArchived?: boolean;
+    isSuspended?: boolean;
+}): boolean;
+/**
+ * Check if a user has all of the specified access keys.
+ *
+ * @param accessKeys - Array of access keys the user has
+ * @param keys - Array of access keys to check for (AND logic)
+ * @param options - Additional options for the check
+ * @returns boolean - true if user has all of the specified keys
+ *
+ * @example
+ * ```ts
+ * const hasAll = hasAllAccess(['admin', 'editor'], ['admin', 'editor']); // true
+ * const hasPartial = hasAllAccess(['admin'], ['admin', 'editor']); // false
+ * ```
+ */
+declare function hasAllAccess(accessKeys: string[] | undefined | null, keys: string[], options?: {
+    isArchived?: boolean;
+    isSuspended?: boolean;
+}): boolean;
+
+/**
+ * Check if a user has entity-level access based on permission check result.
+ * Owners (users with 'owner' access key) bypass entity permissions entirely.
+ *
+ * @param permission - The permission check result from getPermission/usePermission
+ * @param action - The action to check for
+ * @param options - Additional options for the check
+ * @param options.accessKeys - User's access keys (for owner check)
+ * @param options.isArchived - Whether the user is archived
+ * @param options.isSuspended - Whether the user is suspended
+ * @returns boolean - true if user has permission for the action
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * const permission = await getPermission('Project', 123);
+ * const canEdit = hasEntityAccess(permission, 'edit');
+ *
+ * // With owner bypass
+ * const canEditAsOwner = hasEntityAccess(permission, 'edit', {
+ *   accessKeys: ['owner'],
+ * }); // true, owners bypass all checks
+ *
+ * // Check loading state
+ * if (permission.isLoading) {
+ *   return false; // Wait for permission to load
+ * }
+ * ```
+ */
+declare function hasEntityAccess(permission: EntityPermissionCheck | null | undefined, action: EntityAction, options?: {
+    accessKeys?: string[] | null;
+    isArchived?: boolean;
+    isSuspended?: boolean;
+}): boolean;
+/**
+ * Check if a user has any of the specified entity actions.
+ *
+ * @param permission - The permission check result
+ * @param actions - Array of actions to check for (OR logic)
+ * @param options - Additional options for the check
+ * @returns boolean - true if user has permission for any of the actions
+ *
+ * @example
+ * ```ts
+ * const canEditOrDelete = hasAnyEntityAccess(permission, ['edit', 'delete']);
+ * ```
+ */
+declare function hasAnyEntityAccess(permission: EntityPermissionCheck | null | undefined, actions: EntityAction[], options?: {
+    accessKeys?: string[] | null;
+    isArchived?: boolean;
+    isSuspended?: boolean;
+}): boolean;
+/**
+ * Check if a user has all of the specified entity actions.
+ *
+ * @param permission - The permission check result
+ * @param actions - Array of actions to check for (AND logic)
+ * @param options - Additional options for the check
+ * @returns boolean - true if user has permission for all of the actions
+ *
+ * @example
+ * ```ts
+ * // Check if user can edit AND delete (admin-like permissions)
+ * const isAdmin = hasAllEntityAccess(permission, ['edit', 'delete', 'share']);
+ * ```
+ */
+declare function hasAllEntityAccess(permission: EntityPermissionCheck | null | undefined, actions: EntityAction[], options?: {
+    accessKeys?: string[] | null;
+    isArchived?: boolean;
+    isSuspended?: boolean;
+}): boolean;
+/**
+ * Check if entity access was explicitly denied.
+ * Useful for distinguishing between "no permission" and "explicitly blocked".
+ *
+ * @param permission - The permission check result
+ * @returns boolean - true if access was explicitly denied
+ *
+ * @example
+ * ```ts
+ * const permission = await getPermission('Project', 123);
+ * if (isEntityAccessDenied(permission)) {
+ *   showBlockedMessage('You have been explicitly denied access to this project');
+ * }
+ * ```
+ */
+declare function isEntityAccessDenied(permission: EntityPermissionCheck | null | undefined): boolean;
+/**
+ * Type guard to check if permission data is loaded and available.
+ *
+ * @param permission - The permission check result
+ * @returns boolean - true if permission data is loaded
+ *
+ * @example
+ * ```ts
+ * const permission = usePermission('Project', projectId);
+ *
+ * if (!isPermissionLoaded(permission)) {
+ *   return <Spinner />;
+ * }
+ *
+ * // TypeScript knows permission is fully loaded here
+ * return permission.canEdit ? <Editor /> : <Viewer />;
+ * ```
+ */
+declare function isPermissionLoaded(permission: EntityPermissionCheck | null | undefined): permission is EntityPermissionCheck & {
+    isLoading: false;
+};
+
+export { hasAccess, hasAllAccess, hasAllEntityAccess, hasAnyAccess, hasAnyEntityAccess, hasEntityAccess, isEntityAccessDenied, isPermissionLoaded };