@osdk/react 0.8.0 → 0.9.0-beta.10

package/build/types/new/useOsdkObjects.d.ts

@@ -1,13 +1,12 @@
-import type { DerivedProperty, InterfaceDefinition, LinkedType, LinkNames, ObjectTypeDefinition, Osdk, PropertyKeys, WhereClause } from "@osdk/api";
-import type { InferRdpTypes } from "./types.js";
+import type { DerivedProperty, LinkedType, LinkNames, ObjectOrInterfaceDefinition, Osdk, PropertyKeys, SimplePropertyDef, WhereClause } from "@osdk/api";
 export interface UseOsdkObjectsOptions<
-	T extends ObjectTypeDefinition | InterfaceDefinition,
-	WithProps extends DerivedProperty.Clause<T> | undefined = undefined
+	T extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
 > {
 	/**
 	* Standard OSDK Where with RDP support
 	*/
-	where?: WhereClause<T, InferRdpTypes<T, WithProps>>;
+	where?: WhereClause<T, RDPs>;
 	/**
 	*  The preferred page size for the list.
 	*/
@@ -18,14 +17,14 @@ export interface UseOsdkObjectsOptions<
 	* Define derived properties (RDPs) to be computed server-side and attached to each object.
 	* These properties will be available on the returned objects alongside their regular properties.
 	*/
-	withProperties?: WithProps;
+	withProperties?: { [K in keyof RDPs] : DerivedProperty.Creator<T, RDPs[K]> };
 	/**
 	* Intersect the results with additional object sets.
 	* Each element defines a where clause for an object set to intersect with.
 	* The final result will only include objects that match ALL conditions.
 	*/
 	intersectWith?: Array<{
-		where: WhereClause<T, InferRdpTypes<T, WithProps>>
+		where: WhereClause<T, RDPs>
 	}>;
 	/**
 	* Pivot to related objects through a link.
@@ -106,10 +105,25 @@ export interface UseOsdkObjectsOptions<
 	*/
 	enabled?: boolean;
 }
-export interface UseOsdkListResult<T extends ObjectTypeDefinition | InterfaceDefinition> {
+export interface UseOsdkListResult<
+	T extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+> {
+	/**
+	* Function to fetch more pages (undefined if no more pages)
+	*/
 	fetchMore: (() => Promise<void>) | undefined;
-	data: Osdk.Instance<T>[] | undefined;
+	/**
+	* The fetched data with derived properties
+	*/
+	data: Osdk.Instance<T, "$allBaseProperties", PropertyKeys<T>, RDPs>[] | undefined;
+	/**
+	* Whether data is currently being loaded
+	*/
 	isLoading: boolean;
+	/**
+	* Any error that occurred during fetching
+	*/
 	error: Error | undefined;
 	/**
 	* Refers to whether the ordered list of objects (only considering the $primaryKey)
@@ -119,14 +133,18 @@ export interface UseOsdkListResult<T extends ObjectTypeDefinition | InterfaceDef
 	* do that on a per object basis with useOsdkObject
 	*/
 	isOptimistic: boolean;
+	/**
+	* The total count of objects matching the query (if available from the API)
+	*/
+	totalCount?: string;
 }
 export declare function useOsdkObjects<
-	Q extends ObjectTypeDefinition,
+	Q extends ObjectOrInterfaceDefinition,
 	L extends LinkNames<Q>
 >(type: Q, options: UseOsdkObjectsOptions<Q> & {
 	pivotTo: L
 }): UseOsdkListResult<LinkedType<Q, L>>;
 export declare function useOsdkObjects<
-	Q extends ObjectTypeDefinition | InterfaceDefinition,
-	WP extends DerivedProperty.Clause<Q> | undefined
->(type: Q, options?: UseOsdkObjectsOptions<Q, WP>): UseOsdkListResult<Q>;
+	Q extends ObjectOrInterfaceDefinition,
+	RDPs extends Record<string, SimplePropertyDef> = {}
+>(type: Q, options?: UseOsdkObjectsOptions<Q, RDPs>): UseOsdkListResult<Q, RDPs>;

package/build/types/new/useOsdkObjects.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAgBA,cACE,iBACA,qBACA,YACA,WACA,sBACA,MACA,cACA,mBACK,WAAY;AAKnB,cAAc,qBAAqB,YAAa;AAEhD,iBAAiB;CACf,UAAU,uBAAuB;CACjC,kBAAkB,gBAAgB,OAAO;EACzC;;;;CAIA,QAAQ,YAAY,GAAG,cAAc,GAAG;;;;CAKxC;;CAGA,aACG,KAAK,aAAa,OAAM,QAAQ;;;;;CAOnC,iBAAiB;;;;;;CAOjB,gBAAgB,MAAM;EACpB,OAAO,YAAY,GAAG,cAAc,GAAG;CACxC;;;;;CAMD,UAAU,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;CA0BpB;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BA;CAEA;;;;;;;;;;;;;;;;;;;;;CAsBA;AACD;AAED,iBAAiB,kBACf,UAAU,uBAAuB,qBACjC;CACA,kBAAkB;CAClB,MAAM,KAAK,SAAS;CACpB;CAEA,OAAO;;;;;;;;CASP;AACD;AAQD,OAAO,iBAAS;CACd,UAAU;CACV,UAAU,UAAU;EAEpBA,MAAM,GACNC,SAAS,sBAAsB,KAAK;CAAE,SAAS;AAAG,IACjD,kBAAkB,WAAW,GAAG;AAEnC,OAAO,iBAAS;CACd,UAAU,uBAAuB;CACjC,WAAW,gBAAgB,OAAO;EAElCD,MAAM,GACNE,UAAU,sBAAsB,GAAG,MAClC,kBAAkB","names":["type: Q","options: UseOsdkObjectsOptions<Q> & { pivotTo: L }","options?: UseOsdkObjectsOptions<Q, WP>"],"sources":["../../../src/new/useOsdkObjects.ts"],"version":3,"file":"useOsdkObjects.d.ts"}
+{"mappings":"AAgBA,cACE,iBACA,YACA,WACA,6BACA,MACA,cACA,mBACA,mBACK,WAAY;AAMnB,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB,CAAE;EACnD;;;;CAIA,QAAQ,YAAY,GAAG;;;;CAKvB;;CAGA,aACG,KAAK,aAAa,OAAM,QAAQ;;;;;CAOnC,oBAAoB,WAAW,QAAO,gBAAgB,QAAQ,GAAG,KAAK;;;;;;CAOtE,gBAAgB,MAAM;EACpB,OAAO,YAAY,GAAG;CACvB;;;;;CAMD,UAAU,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;CA0BpB;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BA;CAEA;;;;;;;;;;;;;;;;;;;;;CAsBA;AACD;AAED,iBAAiB;CACf,UAAU;CACV,aAAa,eAAe,qBAAqB,CAAE;EACnD;;;;CAIA,kBAAkB;;;;CAKlB,MACI,KAAK,SAAS,GAAG,sBAAsB,aAAa,IAAI;;;;CAM5D;;;;CAKA,OAAO;;;;;;;;CASP;;;;CAKA;AACD;AAQD,OAAO,iBAAS;CACd,UAAU;CACV,UAAU,UAAU;EAEpBA,MAAM,GACNC,SAAS,sBAAsB,KAAK;CAAE,SAAS;AAAG,IACjD,kBAAkB,WAAW,GAAG;AAEnC,OAAO,iBAAS;CACd,UAAU;CACV,aAAa,eAAe,qBAAqB,CAAE;EAEnDD,MAAM,GACNE,UAAU,sBAAsB,GAAG,QAClC,kBAAkB,GAAG","names":["type: Q","options: UseOsdkObjectsOptions<Q> & { pivotTo: L }","options?: UseOsdkObjectsOptions<Q, RDPs>"],"sources":["../../../src/new/useOsdkObjects.ts"],"version":3,"file":"useOsdkObjects.d.ts"}

package/build/types/public/experimental.d.ts

@@ -1,9 +1,14 @@
 export { OsdkProvider2 } from "../new/OsdkProvider2.js";
+export { useCurrentFoundryUser } from "../new/platform-apis/admin/useCurrentFoundryUser.js";
+export { useFoundryUser } from "../new/platform-apis/admin/useFoundryUser.js";
+export { useFoundryUsersList } from "../new/platform-apis/admin/useFoundryUsersList.js";
 export { useLinks } from "../new/useLinks.js";
 export { useObjectSet } from "../new/useObjectSet.js";
 export { useOsdkAction } from "../new/useOsdkAction.js";
 export type { UseOsdkAggregationResult } from "../new/useOsdkAggregation.js";
 export { useOsdkAggregation } from "../new/useOsdkAggregation.js";
+export type { UseOsdkFunctionOptions, UseOsdkFunctionResult } from "../new/useOsdkFunction.js";
+export { useOsdkFunction } from "../new/useOsdkFunction.js";
 export { useOsdkObject } from "../new/useOsdkObject.js";
 export type { UseOsdkListResult } from "../new/useOsdkObjects.js";
 export { useOsdkObjects } from "../new/useOsdkObjects.js";

package/build/types/public/experimental.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAgBA,SAAS,qBAAqB;AAC9B,SAAS,gBAAgB;AACzB,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAC9B,cAAc,gCAAgC;AAC9C,SAAS,0BAA0B;AACnC,SAAS,qBAAqB;AAC9B,cAAc,yBAAyB;AACvC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,cAAc,6BAA6B;AAC3C,SAAS,4BAA4B","names":[],"sources":["../../../src/public/experimental.ts"],"version":3,"file":"experimental.d.ts"}
+{"mappings":"AAgBA,SAAS,qBAAqB;AAC9B,SAAS,6BAA6B;AACtC,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AACpC,SAAS,gBAAgB;AACzB,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAC9B,cAAc,gCAAgC;AAC9C,SAAS,0BAA0B;AACnC,cACE,wBACA,6BACK;AACP,SAAS,uBAAuB;AAChC,SAAS,qBAAqB;AAC9B,cAAc,yBAAyB;AACvC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,cAAc,6BAA6B;AAC3C,SAAS,4BAA4B","names":[],"sources":["../../../src/public/experimental.ts"],"version":3,"file":"experimental.d.ts"}

package/build/types/utils/usePlatformQuery.d.ts

@@ -0,0 +1,25 @@
+export interface UseQueryOptions<T> {
+	/**
+	* Enable or disable the query.
+	*
+	* When `false`, the query will not automatically execute.
+	*
+	* This is useful for:
+	* - Lazy/on-demand queries that should wait for user interaction
+	* - Dependent queries that need data from another query first
+	* - Conditional queries based on component state
+	*
+	* @default true
+	* });
+	*/
+	enabled?: boolean;
+	queryName: string;
+	query: () => Promise<T>;
+}
+export interface QueryResult<T> {
+	data: T | undefined;
+	isLoading: boolean;
+	error: Error | undefined;
+	refetch: () => void;
+}
+export declare function usePlatformQuery<T>({ query, queryName, enabled }: UseQueryOptions<T>): QueryResult<T>;

package/build/types/utils/usePlatformQuery.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAoBA,iBAAiB,gBAAgB,GAAG;;;;;;;;;;;;;;CAclC;CACA;CACA,aAAa,QAAQ;AACtB;AAED,iBAAiB,YAAY,GAAG;CAC9B,MAAM;CACN;CACA,OAAO;CACP;AACD;AAOD,OAAO,iBAAS,iBAAiB,GAC/B,EAAE,OAAO,WAAW,SAAoC,EAAlB,gBAAgB,KACrD,YAAY","names":[],"sources":["../../../src/utils/usePlatformQuery.ts"],"version":3,"file":"usePlatformQuery.d.ts"}

package/docs/actions.md

@@ -0,0 +1,414 @@
+---
+sidebar_position: 3
+---
+
+# Actions
+
+This guide covers executing actions, validation, optimistic updates, and debouncing patterns.
+
+## useOsdkAction
+
+*Experimental - import from `@osdk/react/experimental`*
+
+Execute and validate actions with automatic state management.
+
+### Basic Usage
+
+```tsx
+import { $Actions, Todo } from "@my/osdk";
+import { useOsdkAction, useOsdkObject } from "@osdk/react/experimental";
+import { useCallback } from "react";
+
+function TodoView({ todo }: { todo: Todo.OsdkInstance }) {
+  const { isLoading } = useOsdkObject(todo);
+  const { applyAction, data, error, isPending } = useOsdkAction(
+    $Actions.completeTodo,
+  );
+
+  const onClick = useCallback(() => {
+    applyAction({
+      todo: todo,
+      isComplete: true,
+    });
+  }, [applyAction, todo]);
+
+  return (
+    <div>
+      <div>
+        {todo.title}
+        {todo.isComplete === false && (
+          <button onClick={onClick} disabled={isPending}>
+            Mark Complete
+          </button>
+        )}
+        {isPending && "(Applying)"}
+        {data && "(Action completed successfully)"}
+      </div>
+      {error && (
+        <div>
+          An error occurred:
+          <pre>{JSON.stringify(error, null, 2)}</pre>
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+### Return Values
+
+- `applyAction` - Function to execute the action (accepts single args object or array for batch)
+- `data` - Return value from the last successful action execution
+- `error` - Error object (see error handling below)
+- `isPending` - True while action is executing
+- `isValidating` - True while validation is in progress
+- `validateAction` - Function to validate without executing
+- `validationResult` - Result of last validation
+
+---
+
+## Error Handling
+
+The `error` object has the following structure:
+
+```ts
+{
+  actionValidation?: ActionValidationError;
+  unknown?: unknown;
+}
+```
+
+`ActionValidationError` extends `Error` and has:
+- `message` - Error message string
+- `validation` - Full validation response from server
+
+Example:
+
+```tsx
+import { $Actions, Todo } from "@my/osdk";
+import { useOsdkAction } from "@osdk/react/experimental";
+
+function TodoActionWithErrorHandling({ todo }: { todo: Todo.OsdkInstance }) {
+  const { applyAction, error, isPending } = useOsdkAction($Actions.completeTodo);
+
+  const onClick = async () => {
+    try {
+      await applyAction({ todo, isComplete: true });
+    } catch (e) {
+      console.error("Action failed", e);
+    }
+  };
+
+  return (
+    <div>
+      <button onClick={onClick} disabled={isPending}>
+        Complete Todo
+      </button>
+
+      {error?.actionValidation && (
+        <div style={{ color: "red" }}>
+          Validation failed: {JSON.stringify(error.actionValidation.validation)}
+        </div>
+      )}
+
+      {error?.unknown && (
+        <div style={{ color: "red" }}>
+          An unexpected error occurred: {String(error.unknown)}
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+---
+
+## Validation
+
+Validate action parameters without executing using `validateAction`.
+
+```tsx
+import { $Actions } from "@my/osdk";
+import { useOsdkAction } from "@osdk/react/experimental";
+import { useState } from "react";
+
+function TodoForm() {
+  const [title, setTitle] = useState("");
+  const [assignee, setAssignee] = useState("");
+
+  const {
+    applyAction,
+    validateAction,
+    isValidating,
+    validationResult,
+    isPending,
+    error,
+  } = useOsdkAction($Actions.createTodo);
+
+  const handleTitleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newTitle = e.target.value;
+    setTitle(newTitle);
+    validateAction({ title: newTitle, assignee });
+  };
+
+  const handleAssigneeChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newAssignee = e.target.value;
+    setAssignee(newAssignee);
+    validateAction({ title, assignee: newAssignee });
+  };
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (validationResult?.result === "VALID") {
+      await applyAction({ title, assignee });
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <input
+        type="text"
+        value={title}
+        onChange={handleTitleChange}
+        placeholder="Todo title"
+      />
+      <input
+        type="text"
+        value={assignee}
+        onChange={handleAssigneeChange}
+        placeholder="Assignee"
+      />
+
+      {isValidating && <span>Validating...</span>}
+
+      {validationResult?.result === "INVALID" && (
+        <div style={{ color: "red" }}>
+          Invalid: {JSON.stringify(validationResult)}
+        </div>
+      )}
+
+      <button
+        type="submit"
+        disabled={isPending || isValidating || validationResult?.result !== "VALID"}
+      >
+        Create Todo
+      </button>
+
+      {error?.actionValidation && (
+        <div style={{ color: "red" }}>
+          Validation error: {error.actionValidation.message}
+        </div>
+      )}
+    </form>
+  );
+}
+```
+
+Key features:
+
+- `validateAction` - Validates action parameters without executing
+- `isValidating` - True while validation is in progress
+- `validationResult` - Contains `{ result: "VALID" | "INVALID", ... }`
+- Calling `validateAction` while a previous validation is in progress cancels the previous one
+- Validation and execution are mutually exclusive
+
+---
+
+## Batch Actions
+
+Apply the same action to multiple items in a single call:
+
+```tsx
+import { $Actions, Todo } from "@my/osdk";
+import { useOsdkAction } from "@osdk/react/experimental";
+import { useCallback } from "react";
+
+function BulkCompleteButton({ todos }: { todos: Todo.OsdkInstance[] }) {
+  const { applyAction, isPending } = useOsdkAction($Actions.completeTodo);
+
+  const onClick = useCallback(() => {
+    applyAction(
+      todos.map(todo => ({
+        todo: todo,
+        isComplete: true,
+      })),
+    );
+  }, [applyAction, todos]);
+
+  return (
+    <button onClick={onClick} disabled={isPending}>
+      Complete All ({todos.length})
+    </button>
+  );
+}
+```
+
+---
+
+## Optimistic Updates
+
+Apply changes to the cache immediately while waiting for the server response.
+
+```tsx
+import { $Actions, Todo } from "@my/osdk";
+import { useOsdkAction, useOsdkObject } from "@osdk/react/experimental";
+import { useCallback } from "react";
+
+function TodoView({ todo }: { todo: Todo.OsdkInstance }) {
+  const { isLoading, isOptimistic } = useOsdkObject(todo);
+  const { applyAction, error, isPending } = useOsdkAction($Actions.completeTodo);
+
+  const onClick = useCallback(() => {
+    applyAction({
+      todo: todo,
+      isComplete: true,
+
+      $optimisticUpdate: (ou) => {
+        ou.updateObject(todo.$clone({ isComplete: true }));
+      },
+    });
+  }, [applyAction, todo]);
+
+  return (
+    <div>
+      {todo.title}
+      {todo.isComplete === false && !isOptimistic && (
+        <button onClick={onClick} disabled={isPending}>Mark Complete</button>
+      )}
+      {isPending && "(Saving)"}
+      {isLoading && "(Loading)"}
+      {isOptimistic && "(Optimistic)"}
+      {error && (
+        <div style={{ color: "red" }}>
+          {error.actionValidation?.message ?? String(error.unknown)}
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+### How Optimistic Updates Work
+
+1. When you call `applyAction` with `$optimisticUpdate`, the cache is updated immediately
+2. The UI shows the optimistic state (tracked via `isOptimistic`)
+3. If the action succeeds, the cache is refreshed with server data
+4. If the action fails, the optimistic changes are rolled back automatically
+
+### Optimistic Update API
+
+The `$optimisticUpdate` callback receives an object with the following methods:
+
+```tsx
+$optimisticUpdate: (ou) => {
+  ou.updateObject(todo.$clone({ isComplete: true }));
+  ou.updateObject(anotherObject.$clone({ ... }));
+}
+```
+
+:::note The `$clone` method
+Every OSDK object instance has a `$clone()` method that creates a new object with modified properties. This is essential for optimistic updates because OSDK objects are immutable.
+
+```tsx
+// Create a modified copy without mutating the original
+const completedTodo = todo.$clone({ isComplete: true });
+
+// Clone with multiple property changes
+const updatedTodo = todo.$clone({
+  title: "New Title",
+  priority: "high",
+});
+```
+:::
+
+---
+
+## useDebouncedCallback
+
+*Experimental - import from `@osdk/react/experimental`*
+
+Debounce callback functions for auto-save patterns or expensive operations.
+
+### Basic Usage
+
+```tsx
+import { useDebouncedCallback } from "@osdk/react/experimental";
+import { useState } from "react";
+
+function SearchableList({ onSearch }: { onSearch: (query: string) => void }) {
+  const [query, setQuery] = useState("");
+
+  const debouncedSearch = useDebouncedCallback((q: string) => {
+    onSearch(q);
+  }, 500);
+
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const value = e.target.value;
+    setQuery(value);
+    debouncedSearch(value);
+  };
+
+  return (
+    <input
+      value={query}
+      onChange={handleChange}
+      placeholder="Search..."
+    />
+  );
+}
+```
+
+### Auto-Save Pattern
+
+Combine with actions for auto-saving:
+
+```tsx
+import { $Actions, Todo } from "@my/osdk";
+import { useDebouncedCallback, useOsdkAction } from "@osdk/react/experimental";
+import { useState } from "react";
+
+function AutoSaveTodo({ todo }: { todo: Todo.OsdkInstance }) {
+  const [title, setTitle] = useState(todo.title);
+  const { applyAction } = useOsdkAction($Actions.updateTodo);
+
+  const debouncedSave = useDebouncedCallback((newTitle: string) => {
+    applyAction({
+      todo,
+      title: newTitle,
+      $optimisticUpdate: (ou) => {
+        ou.updateObject(todo.$clone({ title: newTitle }));
+      },
+    });
+  }, 1000);
+
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newTitle = e.target.value;
+    setTitle(newTitle);
+    debouncedSave(newTitle);
+  };
+
+  return (
+    <input
+      value={title}
+      onChange={handleChange}
+      placeholder="Click to edit title..."
+    />
+  );
+}
+```
+
+### Debounced Callback Methods
+
+The returned function has utility methods:
+
+```tsx
+import { useDebouncedCallback } from "@osdk/react/experimental";
+
+const debouncedFn = useDebouncedCallback((value: string) => {
+  console.log("Called with:", value);
+}, 500);
+
+debouncedFn("hello");
+debouncedFn.cancel();
+debouncedFn.flush();
+```