@stigmer/react 3.5.2 → 3.6.0

package/src/schedule/scheduleColumns.tsx

@@ -0,0 +1,118 @@
+"use client";
+
+import { timestampDate } from "@bufbuild/protobuf/wkt";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { formatRelativeTime } from "../activity/format-relative-time.js";
+import { StatusBadge } from "../resource-workbench/components/StatusBadge.js";
+import type { WorkbenchColumnDef } from "../resource-workbench/types.js";
+import { deriveScheduleState, formatNextFire } from "./scheduleState.js";
+
+/** Options for {@link createScheduleColumns}. */
+export interface ScheduleColumnsOptions {
+  /**
+   * Clock provider for the "next fire" and "last run" columns.
+   * Injectable for deterministic tests and Scenar fixtures.
+   * @default () => new Date()
+   */
+  readonly now?: () => Date;
+}
+
+/**
+ * Column set for a schedule workbench — shared by every console so the
+ * list renders identically everywhere (DD-016).
+ *
+ * The columns exist because schedules are listed via the direct query:
+ * each row is a full `Schedule` proto, so the operational fields the
+ * issue calls for (next fire, last run, enabled/paused state) render
+ * straight from the row — no generic `SearchResult` limitations.
+ *
+ * Columns are not sortable: the direct query has one fixed server-side
+ * order (newest first), and a sort affordance that silently does
+ * nothing would lie.
+ */
+export function createScheduleColumns(
+  options?: ScheduleColumnsOptions,
+): WorkbenchColumnDef<Schedule>[] {
+  const now = options?.now ?? (() => new Date());
+
+  return [
+    {
+      id: "name",
+      header: "Name",
+      cell: (item) => (
+        <span className="font-medium text-foreground">
+          {item.metadata?.name || item.metadata?.slug}
+        </span>
+      ),
+      flex: 2,
+    },
+    {
+      id: "state",
+      header: "State",
+      cell: (item) => {
+        const info = deriveScheduleState(item.spec, item.status);
+        return <StatusBadge phase={info.phase} label={info.label} />;
+      },
+      flex: 1,
+    },
+    {
+      id: "cron",
+      header: "Cadence",
+      cell: (item) => (
+        <span className="inline-flex items-baseline gap-1.5">
+          <code className="font-mono text-xs text-foreground">
+            {item.spec?.cron || "—"}
+          </code>
+          <span className="text-xs text-muted-foreground">
+            {item.spec?.timeZone}
+          </span>
+        </span>
+      ),
+      flex: 1.5,
+    },
+    {
+      id: "next-fire",
+      header: "Next fire",
+      cell: (item) => {
+        const info = deriveScheduleState(item.spec, item.status);
+        const nextFireAt = item.status?.nextFireAt;
+        return (
+          <span className="text-muted-foreground">
+            {info.state === "active" && nextFireAt
+              ? formatNextFire(timestampDate(nextFireAt), now())
+              : "—"}
+          </span>
+        );
+      },
+      flex: 1,
+    },
+    {
+      id: "last-run",
+      header: "Last run",
+      cell: (item) => (
+        <span className="text-muted-foreground">
+          {item.status?.lastFireAt
+            ? formatRelativeTime(timestampDate(item.status.lastFireAt), now())
+            : "Never"}
+        </span>
+      ),
+      flex: 1,
+    },
+    {
+      id: "target",
+      header: "Target agent",
+      cell: (item) => {
+        const target =
+          item.spec?.target?.case === "agent" ? item.spec.target.value : undefined;
+        return (
+          <span className="text-muted-foreground">
+            {target?.agentRef
+              ? `${target.agentRef.org}/${target.agentRef.slug}`
+              : "—"}
+          </span>
+        );
+      },
+      flex: 1.5,
+    },
+  ];
+}

package/src/schedule/scheduleListFn.ts

@@ -0,0 +1,108 @@
+// Schedule list fetching — the direct-query core plus the workbench adapter.
+//
+// Schedules are the one Library kind NOT backed by the search service: the
+// generic `SearchResult` summary cannot carry the operational fields a
+// schedule list exists to show (`next_fire_at`, enabled/paused state, last
+// run), while the direct `listSchedules` query returns full `Schedule`
+// protos and was explicitly shaped for "the org-context view a console tab
+// needs". Both consoles consume this single implementation — inlining it
+// per-app would duplicate correctness-bearing pagination logic (DD-016).
+
+import { create } from "@bufbuild/protobuf";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import {
+  ListSchedulesRequestSchema,
+  type ListSchedulesRequest,
+  type ScheduleList,
+} from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
+import type { SearchResult } from "@stigmer/protos/ai/stigmer/search/v1/io_pb";
+import type { ListParams, ListResult } from "@stigmer/sdk";
+
+/** The slice of the Stigmer client this module needs (mockable in tests). */
+export interface ScheduleListClient {
+  readonly schedule: {
+    list(input: ListSchedulesRequest): Promise<ScheduleList>;
+  };
+}
+
+/** One page of schedules, with pagination totals. */
+export interface SchedulePage {
+  /** Full `Schedule` protos (spec + status) for the requested page. */
+  readonly items: readonly Schedule[];
+  /** Total schedules in the org (across all pages). */
+  readonly totalCount: number;
+  /** Total pages at the requested page size. */
+  readonly totalPages: number;
+}
+
+const DEFAULT_PAGE_SIZE = 20;
+
+/**
+ * Fetch one page of an organization's schedules via the direct query.
+ *
+ * Handles a verified split between the two server editions: cloud slices
+ * pages server-side, while the OSS server documents that it ignores
+ * `page_info` and returns every matching schedule. A server that
+ * paginated can never return more rows than the requested size, so an
+ * overflowing response is the tell that the server ignored pagination —
+ * only then is the page sliced locally (absolute indices into the full
+ * list). A cloud page passes through untouched.
+ */
+export async function listSchedulesPage(
+  client: ScheduleListClient,
+  org: string,
+  page: { readonly num?: number; readonly size?: number } = {},
+): Promise<SchedulePage> {
+  const size = page.size && page.size > 0 ? page.size : DEFAULT_PAGE_SIZE;
+  const num = page.num && page.num > 0 ? page.num : 1;
+
+  const result = await client.schedule.list(
+    create(ListSchedulesRequestSchema, {
+      org,
+      pageInfo: { num, size },
+    }),
+  );
+
+  const items =
+    result.items.length > size
+      ? result.items.slice((num - 1) * size, num * size)
+      : result.items;
+
+  return {
+    items,
+    totalCount: result.totalCount,
+    totalPages: Math.ceil(result.totalCount / size),
+  };
+}
+
+/**
+ * Build a `ResourceWorkbench`-compatible `listFn` over the direct
+ * schedule query.
+ *
+ * The returned entries are full `Schedule` protos occupying the
+ * `SearchResult` slot of `ListResult` — `ResourceWorkbench` is generic
+ * over its row type (`useResourceCollection` casts entries through to
+ * `TData`), and this is the one documented place where that cast
+ * happens. Consumers type their workbench as
+ * `ResourceWorkbench<Schedule>` and pass `getItemId={(s) => s.metadata?.id}`.
+ *
+ * `params.query` and `params.crossOrgPublic` are ignored: schedules have
+ * no server-side text search (render the workbench with
+ * `searchable={false}`) and are never public/cross-org.
+ */
+export function createScheduleListFn(
+  client: ScheduleListClient,
+): (params: ListParams) => Promise<ListResult> {
+  return async (params: ListParams): Promise<ListResult> => {
+    const { items, totalCount, totalPages } = await listSchedulesPage(
+      client,
+      params.org,
+      params.page ?? {},
+    );
+    return {
+      entries: items as unknown as SearchResult[],
+      totalCount,
+      totalPages,
+    };
+  };
+}

package/src/schedule/scheduleState.ts

@@ -0,0 +1,96 @@
+// Pure schedule-state derivation — the disabled-vs-paused vocabulary,
+// computed on read.
+//
+// A schedule that is not firing is stopped by one of two levers with two
+// different writers and two different remedies (the backend pins this
+// vocabulary in its controller docs):
+//
+//   - "disabled" — the OWNER's switch (`spec.enabled = false`), cleared
+//     by re-applying the manifest or the console's Enable action.
+//   - "paused" — the PLATFORM's failure-streak latch
+//     (`status.paused_reason` non-empty), cleared only by Resume.
+//
+// The console must never collapse these into one badge (stigmer/stigmer#352):
+// each state names its own remedy. When both levers are set, "disabled"
+// wins for display — the owner's intent dominates — but callers should
+// keep the paused reason visible alongside (the banner does).
+
+import type { ScheduleSpec } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/spec_pb";
+import type { ScheduleStatus } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/status_pb";
+import type { StatusPhase } from "../resource-workbench/types.js";
+
+/** The three mutually-exclusive display states of a schedule. */
+export type ScheduleState = "active" | "disabled" | "paused";
+
+/** Derived display state: the tri-state plus its shared-badge rendering. */
+export interface ScheduleStateInfo {
+  /** The display state ("disabled" wins when both levers are set). */
+  readonly state: ScheduleState;
+  /** `StatusPhase` for the shared `StatusBadge` (`--stgm-status-*` tokens). */
+  readonly phase: StatusPhase;
+  /** Human-readable badge label. */
+  readonly label: string;
+  /**
+   * `true` when the platform pause latch is set — independent of the
+   * display state, so a disabled-AND-paused schedule can still surface
+   * its `status.pausedReason`.
+   */
+  readonly isPaused: boolean;
+}
+
+/**
+ * Derive a schedule's display state from its spec and status.
+ *
+ * A missing spec derives as "disabled" — the same fail-closed reading the
+ * server applies to a manifest that omits `enabled`.
+ */
+export function deriveScheduleState(
+  spec: ScheduleSpec | undefined,
+  status: ScheduleStatus | undefined,
+): ScheduleStateInfo {
+  const isPaused = (status?.pausedReason ?? "") !== "";
+
+  if (!spec?.enabled) {
+    return { state: "disabled", phase: "disabled", label: "Disabled", isPaused };
+  }
+  if (isPaused) {
+    return { state: "paused", phase: "degraded", label: "Paused", isPaused };
+  }
+  return { state: "active", phase: "ready", label: "Active", isPaused };
+}
+
+/**
+ * Compact future-instant formatter for a schedule's next fire time:
+ * `now`, `in 5m`, `in 3h`, `in 6d`, then a short date once "days from
+ * now" stops being how people think about it.
+ *
+ * The schedule-local sibling of the activity module's past-only
+ * `formatRelativeTime` (same compact units, same date tail) — kept
+ * separate because that util's contract is deliberately past-only.
+ * A fire time slightly in the past (a tick mid-flight, clock skew)
+ * renders as `now` rather than a nonsense negative countdown.
+ *
+ * `now` is injected, never read from the live clock — required for
+ * deterministic tests and Scenar fixtures.
+ */
+export function formatNextFire(date: Date, now: Date): string {
+  const deltaMs = date.getTime() - now.getTime();
+
+  if (deltaMs < 60_000) return "now";
+
+  const minutes = Math.floor(deltaMs / 60_000);
+  if (minutes < 60) return `in ${minutes}m`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `in ${hours}h`;
+
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `in ${days}d`;
+
+  const sameYear = date.getFullYear() === now.getFullYear();
+  return date.toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+    ...(sameYear ? {} : { year: "numeric" }),
+  });
+}

package/src/schedule/useCreateSchedule.ts

@@ -0,0 +1,88 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import type { ScheduleInput } from "@stigmer/sdk";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useCreateSchedule}. */
+export interface UseCreateScheduleReturn {
+  /**
+   * Submit a {@link ScheduleInput} to create (or upsert) a schedule.
+   *
+   * Uses `stigmer.schedule.apply()` — the idempotent upsert operation.
+   * Resolves with the server-created `Schedule` proto including
+   * populated metadata (id, slug, audit timestamps) and the
+   * platform-computed `status.next_fire_at`.
+   */
+  readonly create: (input: ScheduleInput) => Promise<Schedule>;
+  /** `true` while the apply request is in flight. */
+  readonly isCreating: boolean;
+  /** Error from the last failed create, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Reset `error` to `null`. */
+  readonly clearError: () => void;
+}
+
+/**
+ * Behavior hook that wraps `schedule.apply()` with loading and error
+ * state.
+ *
+ * Creates a schedule from a {@link ScheduleInput}. Uses `apply()`
+ * (upsert) rather than `create()` so re-submissions are idempotent —
+ * matching the CLI's `stigmer apply` semantics and the established SDK
+ * mutation hook pattern (`isCreating` flag, `error` state, `clearError`
+ * reset, result returned from the promise, not stored in hook state).
+ *
+ * NOTE: this hook is for CREATION. Editing an existing schedule must
+ * NOT go through `ScheduleInput` — the input type cannot express every
+ * metadata field (tags, description), and the server replaces spec and
+ * mutable metadata wholesale on update, so a down-converting edit would
+ * silently wipe them. Edit flows use the full-proto path instead (see
+ * `useSetScheduleEnabled` for the pattern).
+ *
+ * @example
+ * ```tsx
+ * const { create, isCreating, error, clearError } = useCreateSchedule();
+ *
+ * const schedule = await create({
+ *   name: "daily-fee-reminders",
+ *   org: "acme",
+ *   cron: "0 9 * * *",
+ *   timeZone: "Asia/Kolkata",
+ *   enabled: false,
+ *   agent: {
+ *     agentRef: { org: "acme", slug: "billing-assistant" },
+ *     message: "Send today's fee reminders.",
+ *   },
+ * });
+ * // schedule.metadata?.slug → "daily-fee-reminders"
+ * ```
+ */
+export function useCreateSchedule(): UseCreateScheduleReturn {
+  const stigmer = useStigmer();
+  const [isCreating, setIsCreating] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const clearError = useCallback(() => setError(null), []);
+
+  const create = useCallback(
+    async (input: ScheduleInput): Promise<Schedule> => {
+      setIsCreating(true);
+      setError(null);
+
+      try {
+        return await stigmer.schedule.apply(input);
+      } catch (err) {
+        setError(toError(err));
+        throw err;
+      } finally {
+        setIsCreating(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return { create, isCreating, error, clearError };
+}

package/src/schedule/useResumeSchedule.ts

@@ -0,0 +1,67 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { getUserMessage } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { toast } from "../feedback/toast.js";
+import { toError } from "../internal/toError.js";
+
+/** Return value of {@link useResumeSchedule}. */
+export interface UseResumeScheduleReturn {
+  /**
+   * Clear the platform's failure-streak pause and let the schedule fire
+   * again. Resolves with the post-resume schedule; the caller refetches
+   * or replaces its local copy from it.
+   */
+  readonly resumeSchedule: (scheduleId: string) => Promise<Schedule>;
+  /** `true` while the resume request is in flight. */
+  readonly isResuming: boolean;
+  /** Error from the last failed resume, or `null` when healthy. */
+  readonly error: Error | null;
+}
+
+/**
+ * Behavior hook that resumes a platform-paused schedule.
+ *
+ * Resume is the ONE path that clears `status.paused_reason` (and the
+ * failure streak with it) — re-applying the manifest deliberately does
+ * not, so a routine GitOps apply can never silently un-pause a failing
+ * schedule. Resuming a schedule that is not paused is a server-side
+ * no-op; resuming a disabled schedule clears the pause but the schedule
+ * stays disabled (the owner's lever is separate — see
+ * {@link useSetScheduleEnabled}).
+ *
+ * Error toasts relay the server's message verbatim: the copy is
+ * identical across editions and states the remedy.
+ */
+export function useResumeSchedule(): UseResumeScheduleReturn {
+  const stigmer = useStigmer();
+  const [isResuming, setIsResuming] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const resumeSchedule = useCallback(
+    async (scheduleId: string): Promise<Schedule> => {
+      setIsResuming(true);
+      setError(null);
+      try {
+        const resumed = await stigmer.schedule.resume(scheduleId);
+        toast.success("Schedule resumed");
+        return resumed;
+      } catch (err) {
+        const wrapped = toError(err);
+        setError(wrapped);
+        toast.error(getUserMessage(err));
+        throw wrapped;
+      } finally {
+        setIsResuming(false);
+      }
+    },
+    [stigmer],
+  );
+
+  return useMemo(
+    () => ({ resumeSchedule, isResuming, error }),
+    [resumeSchedule, isResuming, error],
+  );
+}

package/src/schedule/useSchedule.ts

@@ -0,0 +1,67 @@
+"use client";
+
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { isNotFound } from "@stigmer/sdk";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
+
+/** Return value of {@link useSchedule}. */
+export interface UseScheduleReturn {
+  /** The resolved schedule, or `null` while loading, on error, or when not found. */
+  readonly schedule: Schedule | null;
+  /** `true` while the initial fetch is in flight. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch the schedule from the server. */
+  readonly refetch: () => void;
+}
+
+/**
+ * Data hook that fetches a single Schedule by organization and slug.
+ *
+ * Wraps `stigmer.schedule.getByReference()` with loading, error, and
+ * not-found state management. The loaded resource carries the spec
+ * (cron, time zone, enabled, target) and the platform-written status
+ * (`next_fire_at`, `last_fire_at`, `last_execution_id`,
+ * `consecutive_failures`, `paused_reason`) — everything the detail view
+ * renders, including the disabled-vs-paused distinction (see
+ * {@link deriveScheduleState}).
+ *
+ * Pass `null` for either `org` or `slug` to skip fetching (stable
+ * no-op).
+ *
+ * **Not-found handling:** a NOT_FOUND response sets `schedule` to
+ * `null` without raising an error; `schedule === null && !isLoading
+ * && !error` means the resource does not exist.
+ *
+ * @example
+ * ```tsx
+ * const { schedule, isLoading, error, refetch } = useSchedule("isc", "daily-fee-reminders");
+ * ```
+ */
+export function useSchedule(
+  org: string | null,
+  slug: string | null,
+): UseScheduleReturn {
+  const stigmer = useStigmer();
+
+  const { data: schedule, isLoading, isRefetching, error, refetch } = useFetch(
+    org && slug
+      ? async () => {
+          try {
+            return await stigmer.schedule.getByReference({ org, slug });
+          } catch (err) {
+            if (isNotFound(err)) return null;
+            throw err;
+          }
+        }
+      : null,
+    [org, slug, stigmer],
+    null,
+  );
+
+  return { schedule, isLoading, isRefetching, error, refetch };
+}

package/src/schedule/useScheduleCount.ts

@@ -0,0 +1,57 @@
+"use client";
+
+import { useMemo } from "react";
+import { useStigmer } from "../hooks.js";
+import { useResourceCount } from "../search/index.js";
+import { createScheduleListFn } from "./scheduleListFn.js";
+
+/** Options for {@link useScheduleCount}. */
+export interface UseScheduleCountOptions {
+  /** Opaque token that forces a recount when its value changes. */
+  readonly refetchToken?: unknown;
+}
+
+/** Return value of {@link useScheduleCount}. */
+export interface UseScheduleCountReturn {
+  /**
+   * Total number of schedules in the organization. `undefined` until
+   * the first successful fetch completes.
+   */
+  readonly count: number | undefined;
+  /** `true` while the count fetch is in flight. */
+  readonly isLoading: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch the count from the server. */
+  readonly refetch: () => void;
+}
+
+/**
+ * Data hook that fetches the total count of an organization's schedules.
+ *
+ * Issues a minimal direct `listSchedules` call to retrieve only the
+ * total count. Useful for the Library landing card and dashboard
+ * widgets. There is no scope option: schedules are org-only.
+ *
+ * For the full paginated schedule list, use {@link useScheduleList}
+ * instead.
+ *
+ * Pass `null` as `org` to skip fetching (stable no-op).
+ *
+ * @example
+ * ```tsx
+ * const { count, isLoading } = useScheduleCount("isc");
+ * ```
+ */
+export function useScheduleCount(
+  org: string | null,
+  options?: UseScheduleCountOptions,
+): UseScheduleCountReturn {
+  const stigmer = useStigmer();
+
+  const listFn = useMemo(() => createScheduleListFn(stigmer), [stigmer]);
+
+  return useResourceCount(listFn, org, {
+    refetchToken: options?.refetchToken,
+  });
+}

package/src/schedule/useScheduleList.ts

@@ -0,0 +1,83 @@
+"use client";
+
+import type { Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
+import { listSchedulesPage, type SchedulePage } from "./scheduleListFn.js";
+
+/** Options for {@link useScheduleList}. */
+export interface UseScheduleListOptions {
+  /** Maximum schedules per page. @default 20 */
+  readonly pageSize?: number;
+  /** Page number (1-indexed). @default 1 */
+  readonly page?: number;
+}
+
+/** Return value of {@link useScheduleList}. */
+export interface UseScheduleListReturn {
+  /** Full `Schedule` protos (spec + status) for the current page. */
+  readonly schedules: readonly Schedule[];
+  /** Total number of schedules in the organization. */
+  readonly totalCount: number;
+  /** Total pages available at the current page size. */
+  readonly totalPages: number;
+  /** The current page number (mirrors the `page` option). */
+  readonly currentPage: number;
+  /** `true` while the initial fetch is in flight. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch the current page from the server. */
+  readonly refetch: () => void;
+}
+
+const INITIAL_PAGE: SchedulePage = { items: [], totalCount: 0, totalPages: 0 };
+
+/**
+ * Data hook that fetches a paginated list of an organization's schedules.
+ *
+ * Backed by the direct `listSchedules` query — not the search service —
+ * so each entry is a full `Schedule` proto with the operational status
+ * fields a schedule list exists to show (`next_fire_at`, enabled/paused
+ * state, `last_fire_at`). There is no text query or visibility scope:
+ * schedules are org-only and have no server-side search.
+ *
+ * Pass `null` as `org` to skip fetching (stable no-op).
+ *
+ * @example
+ * ```tsx
+ * const { schedules, totalCount, isLoading } = useScheduleList("isc", {
+ *   page: 1,
+ *   pageSize: 20,
+ * });
+ * ```
+ */
+export function useScheduleList(
+  org: string | null,
+  options?: UseScheduleListOptions,
+): UseScheduleListReturn {
+  const stigmer = useStigmer();
+  const pageSize = options?.pageSize;
+  const page = options?.page ?? 1;
+
+  const { data, isLoading, isRefetching, error, refetch } = useFetch<SchedulePage>(
+    org
+      ? () => listSchedulesPage(stigmer, org, { num: page, size: pageSize })
+      : null,
+    [stigmer, org, page, pageSize],
+    INITIAL_PAGE,
+  );
+
+  return {
+    schedules: data.items,
+    totalCount: data.totalCount,
+    totalPages: data.totalPages,
+    currentPage: page,
+    isLoading,
+    isRefetching,
+    error,
+    refetch,
+  };
+}