Fe overhaul burndown 1 (#1563)

* chore: improve error on dispatcher (#1538)

* fix: empty billing context (#1553)

* fix: empty

* precommit

* hotfix: priority nil pointer (#1555)

* hotfix: priority on schedule workflow (#1556)

* hotfix: priority on schedule workflow

* fix: build

* Hotfix: Handle EOF Properly (#1557)

* fix: handle EOF properly

* chore: version

* fix: debug logs

* fix: rm eof type

* hotfix: priority on cron workflow for v0 (#1558)

* fix: one more possible null deref (#1560)

* Hatchet Python Blog Post (#1526)

* feat: initial pass at first parts of blog post

* feat: initial mkdocs setup

* feat: first pass at embedding mkdocs

* fix: config

* debug: paths

* fix: unwind docs hack

* feat: start working on mkdocs theme

* fix: paths

* feat: wrap up post

* fix: proof

* fix: doc links

* fix: rm docs

* fix: lint

* fix: lint

* fix: typos + tweak

* fix: tweaks

* fix: typo

* fix: cleanup

* fix: go signature and docs (#1561)

* fix: go signature and docs

* Update examples/v1/workflows/concurrency-rr.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* feat: toggle doc sheet

* docs: concurrency cleanup (#1562)

* feat: storage adapter

* docs--worker-config-options (#1535)

* docs--worker-config-options

* Update frontend/docs/pages/home/workers.mdx

Co-authored-by: abelanger5 <belanger@sas.upenn.edu>

* Update worker-configuration-options.mdx

* lint

---------

Co-authored-by: abelanger5 <belanger@sas.upenn.edu>

---------

Co-authored-by: abelanger5 <belanger@sas.upenn.edu>
Co-authored-by: Matt Kaye <mrkaye97@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 4 people

examples/v1/worker/start.go

@@ -1,12 +1,12 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"os"
 	"time"
 
 	v1_workflows "github.com/hatchet-dev/hatchet/examples/v1/workflows"
+	"github.com/hatchet-dev/hatchet/pkg/cmdutils"
 	v1 "github.com/hatchet-dev/hatchet/pkg/v1"
 	"github.com/hatchet-dev/hatchet/pkg/v1/worker"
 	"github.com/hatchet-dev/hatchet/pkg/v1/workflow"
@@ -82,9 +82,9 @@ func main() {
 		panic(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
+	interruptCtx, cancel := cmdutils.NewInterruptContext()
 
-	err = worker.StartBlocking(ctx)
+	err = worker.StartBlocking(interruptCtx)
 
 	if err != nil {
 		panic(err)

examples/v1/workflows/concurrency-rr.go

@@ -13,25 +13,62 @@ import (
 )
 
 type ConcurrencyInput struct {
-	Message  string
-	GroupKey string
+	Message string
+	Tier    string
+	Account string
 }
 
 type TransformedOutput struct {
 	TransformedMessage string
 }
 
 func ConcurrencyRoundRobin(hatchet v1.HatchetClient) workflow.WorkflowDeclaration[ConcurrencyInput, TransformedOutput] {
+	// ❓ Concurrency Strategy With Key
+	var maxRuns int32 = 1
 	strategy := types.GroupRoundRobin
 
-	// ❓ Concurrency Strategy With Key
 	concurrency := factory.NewTask(
 		create.StandaloneTask{
 			Name: "simple-concurrency",
 			Concurrency: []*types.Concurrency{
 				{
 					Expression:    "input.GroupKey",
-					MaxRuns:       &[]int32{1}[0],
+					MaxRuns:       &maxRuns,
+					LimitStrategy: &strategy,
+				},
+			},
+		}, func(ctx worker.HatchetContext, input ConcurrencyInput) (*TransformedOutput, error) {
+			// Random sleep between 200ms and 1000ms
+			time.Sleep(time.Duration(200+rand.Intn(800)) * time.Millisecond)
+
+			return &TransformedOutput{
+				TransformedMessage: input.Message,
+			}, nil
+		},
+		hatchet,
+	)
+	// !!
+
+	return concurrency
+}
+
+func MultipleConcurrencyKeys(hatchet v1.HatchetClient) workflow.WorkflowDeclaration[ConcurrencyInput, TransformedOutput] {
+	// ❓ Multiple Concurrency Keys
+	strategy := types.GroupRoundRobin
+	var maxRuns int32 = 20
+
+	concurrency := factory.NewTask(
+		create.StandaloneTask{
+			Name: "simple-concurrency",
+			Concurrency: []*types.Concurrency{
+				{
+					Expression:    "input.Tier",
+					MaxRuns:       &maxRuns,
+					LimitStrategy: &strategy,
+				},
+				{
+					Expression:    "input.Account",
+					MaxRuns:       &maxRuns,
 					LimitStrategy: &strategy,
 				},
 			},

examples/v1/workflows/simple.go

@@ -63,7 +63,7 @@ func Simple(hatchet v1.HatchetClient) workflow.WorkflowDeclaration[SimpleInput,
 		if err != nil {
 			return err
 		}
-		err = w.StartBlocking()
+		err = w.StartBlocking(context.Background())
 		if err != nil {
 			return err
 		}

frontend/app/src/next/hooks/use-docs-sheet.ts

@@ -17,6 +17,7 @@ export interface DocsSheet {
 export interface DocsContextValue {
   sheet: DocsSheet;
   open: (doc: DocRef) => void;
+  toggle: (doc: DocRef) => void;
   close: () => void;
 }
 
@@ -33,6 +34,7 @@ export function useDocs() {
   }
   return {
     open: context.open,
+    toggle: context.toggle,
     close: context.close,
     sheet: context.sheet,
   };
@@ -61,9 +63,18 @@ export function useDocsState(): DocsContextValue {
     }));
   };
 
+  const toggleSheet = (doc: DocRef) => {
+    if (sheet.isOpen) {
+      closeSheet();
+    } else {
+      openSheet(doc);
+    }
+  };
+
   return {
     sheet,
     open: openSheet,
+    toggle: toggleSheet,
     close: closeSheet,
   };
 }

frontend/app/src/next/hooks/use-filters.tsx

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { useStateAdapter } from '../lib/utils/storage-adapter';
 
 export interface FilterManager<T> {
   filters: T;
@@ -20,6 +21,10 @@ const FilterContext = React.createContext<FilterContextType<any> | undefined>(
   undefined,
 );
 
+/**
+ * Hook to access the current filter state and filter management functions
+ * @returns FilterManager instance with filter management functions
+ */
 export function useFilters<T>() {
   const context = React.useContext<FilterContextType<T> | undefined>(
     FilterContext,
@@ -31,35 +36,63 @@ export function useFilters<T>() {
   return context as FilterManager<T>;
 }
 
+// Storage type for filters - either in-memory state or URL query parameters
+type FilterType = 'state' | 'query';
+
 interface FilterProviderProps<T extends Record<string, any>> {
   children: React.ReactNode;
   initialFilters?: T;
+  /**
+   * Storage type for filters:
+   * - 'query': Store filters in URL query parameters (default)
+   * - 'state': Store filters in component state
+   */
+  type?: FilterType;
 }
 
+/**
+ * Provider component that manages filter state
+ * @param props.children - React children
+ * @param props.initialFilters - Initial filter values
+ * @param props.type - Storage type ('query' or 'state')
+ */
 export function FilterProvider<T extends Record<string, any>>({
   children,
   initialFilters = {} as T,
+  type = 'query',
 }: FilterProviderProps<T>) {
-  const [filters, setFilters] = React.useState<T>(initialFilters);
+  // Initialize the storage with default values and a prefix to avoid collisions
+  const state = useStateAdapter<T>(initialFilters, {
+    type,
+    prefix: 'filter_',
+  });
 
-  const setFilter = React.useCallback((key: keyof T, value: T[keyof T]) => {
-    setFilters((prev) => ({
-      ...prev,
-      [key]: value,
-    }));
-  }, []);
+  // Get current filters from the storage adapter
+  const filters = state.getValues();
 
-  const clearFilter = React.useCallback((key: keyof T) => {
-    setFilters((prev) => {
-      const newFilters = { ...prev };
-      delete newFilters[key];
-      return newFilters;
-    });
-  }, []);
+  // Set a single filter value
+  const setFilter = React.useCallback(
+    (key: keyof T, value: T[keyof T]) => {
+      state.setValue(key as string, value);
+    },
+    [state],
+  );
 
+  // Clear a single filter
+  const clearFilter = React.useCallback(
+    (key: keyof T) => {
+      state.setValue(key as string, undefined as any);
+    },
+    [state],
+  );
+
+  // Clear all filters
   const clearAllFilters = React.useCallback(() => {
-    setFilters({} as T);
-  }, []);
+    const currentFilters = state.getValues();
+    Object.keys(currentFilters).forEach((key) => {
+      state.setValue(key, undefined as any);
+    });
+  }, [state]);
 
   const value = React.useMemo(
     () => ({

frontend/app/src/next/hooks/use-pagination.tsx

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { useStateAdapter } from '../lib/utils/storage-adapter';
 
 export interface PaginationManager {
   currentPage: number;
@@ -26,6 +27,10 @@ const PaginationContext = React.createContext<
   PaginationContextType | undefined
 >(undefined);
 
+/**
+ * Hook to access the current pagination state and pagination management functions
+ * @returns PaginationManager instance with pagination state and functions
+ */
 export function usePagination() {
   const context = React.useContext(PaginationContext);
   if (!context) {
@@ -34,32 +39,80 @@ export function usePagination() {
   return context;
 }
 
+// Storage type for pagination - either in-memory state or URL query parameters
+type PaginationType = 'state' | 'query';
+
 interface PaginationProviderProps {
   children: React.ReactNode;
   initialPage?: number;
   initialPageSize?: number;
   pageSizeOptions?: number[];
+  /**
+   * Storage type for pagination:
+   * - 'query': Store pagination in URL query parameters (default)
+   * - 'state': Store pagination in component state
+   */
+  type?: PaginationType;
 }
 
+// Define the type for pagination state
+interface PaginationState {
+  page: number;
+  pageSize: number;
+}
+
+/**
+ * Provider component that manages pagination state
+ * @param props.children - React children
+ * @param props.initialPage - Initial page number (default: 1)
+ * @param props.initialPageSize - Initial page size (default: 50)
+ * @param props.pageSizeOptions - Available page size options
+ * @param props.type - Storage type ('query' or 'state')
+ */
 export function PaginationProvider({
   children,
   initialPage = 1,
   initialPageSize = 50,
   pageSizeOptions = [10, 50, 100, 500],
+  type = 'query',
 }: PaginationProviderProps) {
-  const [currentPage, setCurrentPage] = React.useState(initialPage);
-  const [pageSize, setPageSize] = React.useState(initialPageSize);
+  // Initialize the storage with default values
+  const state = useStateAdapter<PaginationState>(
+    {
+      page: initialPage,
+      pageSize: initialPageSize,
+    },
+    { type },
+  );
+
   const [numPages, setNumPages] = React.useState(1);
 
+  // Get current values from the storage adapter
+  const currentPage = state.getValue('page', initialPage);
+  const pageSize = state.getValue('pageSize', initialPageSize);
+
+  // Set current page through the adapter
+  const setCurrentPage = React.useCallback(
+    (page: number) => {
+      state.setValue('page', page);
+    },
+    [state],
+  );
+
+  // Handle page size change through the adapter
   const handlePageSizeChange = React.useCallback(
     (newPageSize: number) => {
-      setPageSize(newPageSize);
+      state.setValue('pageSize', newPageSize);
+
       // Calculate the new number of pages based on the new page size
       const newNumPages = Math.ceil((currentPage * pageSize) / newPageSize);
+
       // Ensure current page is valid
-      setCurrentPage(Math.min(currentPage, newNumPages));
+      if (currentPage > newNumPages) {
+        state.setValue('page', Math.min(currentPage, newNumPages));
+      }
     },
-    [currentPage, pageSize],
+    [currentPage, pageSize, state],
   );
 
   const value = React.useMemo(
@@ -72,7 +125,14 @@ export function PaginationProvider({
       setNumPages,
       pageSizeOptions,
     }),
-    [currentPage, pageSize, numPages, pageSizeOptions, handlePageSizeChange],
+    [
+      currentPage,
+      pageSize,
+      numPages,
+      pageSizeOptions,
+      handlePageSizeChange,
+      setCurrentPage,
+    ],
   );
 
   return (

frontend/app/src/next/lib/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './cn';
 export * from './capitalize';
 export * from './name-generator';
+export * from './storage-adapter';