@constructive-io/react 0.23.16 → 0.24.0

package/esm/compute/hooks/queries/useFunctionGraphExecutionNodeStatesQuery.js

@@ -0,0 +1,32 @@
+/**
+ * Per-node execution state — tracks individual node lifecycle for debugging
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildListSelectionArgs } from '../selection';
+import { functionGraphExecutionNodeStateKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const functionGraphExecutionNodeStatesQueryKey = functionGraphExecutionNodeStateKeys.list;
+export function useFunctionGraphExecutionNodeStatesQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: functionGraphExecutionNodeStateKeys.list(args),
+        queryFn: () => getClient().functionGraphExecutionNodeState.findMany(args).unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchFunctionGraphExecutionNodeStatesQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    return getClient().functionGraphExecutionNodeState.findMany(args).unwrap();
+}
+export async function prefetchFunctionGraphExecutionNodeStatesQuery(queryClient, params) {
+    const args = buildListSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: functionGraphExecutionNodeStateKeys.list(args),
+        queryFn: () => getClient().functionGraphExecutionNodeState.findMany(args).unwrap(),
+    });
+}

package/esm/compute/hooks/queries/useFunctionGraphExecutionOutputQuery.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { FunctionGraphExecutionOutputSelect, FunctionGraphExecutionOutputWithRelations } from '../../orm/input-types';
+import type { InferSelectResult, HookStrictSelect } from '../../orm/select-types';
+export type { FunctionGraphExecutionOutputSelect, FunctionGraphExecutionOutputWithRelations, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const functionGraphExecutionOutputQueryKey: (id: string | number) => readonly ["functiongraphexecutionoutput", "detail", string | number];
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFunctionGraphExecutionOutputQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true, name: true } },
+ * });
+ * ```
+ */
+export declare function useFunctionGraphExecutionOutputQuery<S extends FunctionGraphExecutionOutputSelect, TData = {
+    functionGraphExecutionOutput: InferSelectResult<FunctionGraphExecutionOutputWithRelations, S> | null;
+}>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionOutputSelect>;
+} & Omit<UseQueryOptions<{
+    functionGraphExecutionOutput: InferSelectResult<FunctionGraphExecutionOutputWithRelations, S> | null;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ *
+ * @example
+ * ```ts
+ * const data = await fetchFunctionGraphExecutionOutputQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true } },
+ * });
+ * ```
+ */
+export declare function fetchFunctionGraphExecutionOutputQuery<S extends FunctionGraphExecutionOutputSelect>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionOutputSelect>;
+}): Promise<{
+    functionGraphExecutionOutput: InferSelectResult<FunctionGraphExecutionOutputWithRelations, S> | null;
+}>;
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ *
+ * @example
+ * ```ts
+ * await prefetchFunctionGraphExecutionOutputQuery(queryClient, { id: 'some-id', selection: { fields: { id: true } } });
+ * ```
+ */
+export declare function prefetchFunctionGraphExecutionOutputQuery<S extends FunctionGraphExecutionOutputSelect>(queryClient: QueryClient, params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionOutputSelect>;
+}): Promise<void>;

package/esm/compute/hooks/queries/useFunctionGraphExecutionOutputQuery.js

@@ -0,0 +1,47 @@
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildSelectionArgs } from '../selection';
+import { functionGraphExecutionOutputKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const functionGraphExecutionOutputQueryKey = functionGraphExecutionOutputKeys.detail;
+export function useFunctionGraphExecutionOutputQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: functionGraphExecutionOutputKeys.detail(params.id),
+        queryFn: () => getClient()
+            .functionGraphExecutionOutput.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchFunctionGraphExecutionOutputQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    return getClient()
+        .functionGraphExecutionOutput.findOne({
+        id: params.id,
+        select: args.select,
+    })
+        .unwrap();
+}
+export async function prefetchFunctionGraphExecutionOutputQuery(queryClient, params) {
+    const args = buildSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: functionGraphExecutionOutputKeys.detail(params.id),
+        queryFn: () => getClient()
+            .functionGraphExecutionOutput.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+    });
+}

package/esm/compute/hooks/queries/useFunctionGraphExecutionOutputsQuery.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { ListSelectionConfig } from '../selection';
+import type { FunctionGraphExecutionOutputSelect, FunctionGraphExecutionOutputWithRelations, FunctionGraphExecutionOutputFilter, FunctionGraphExecutionOutputOrderBy } from '../../orm/input-types';
+import type { InferSelectResult, ConnectionResult, HookStrictSelect } from '../../orm/select-types';
+export type { FunctionGraphExecutionOutputSelect, FunctionGraphExecutionOutputWithRelations, FunctionGraphExecutionOutputFilter, FunctionGraphExecutionOutputOrderBy, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const functionGraphExecutionOutputsQueryKey: (variables?: object) => readonly ["functiongraphexecutionoutput", "list", object];
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFunctionGraphExecutionOutputsQuery({
+ *   selection: {
+ *     fields: { id: true, name: true },
+ *     where: { name: { equalTo: "example" } },
+ *     orderBy: ['CREATED_AT_DESC'],
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function useFunctionGraphExecutionOutputsQuery<S extends FunctionGraphExecutionOutputSelect, TData = {
+    functionGraphExecutionOutputs: ConnectionResult<InferSelectResult<FunctionGraphExecutionOutputWithRelations, S>>;
+}>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphExecutionOutputFilter, FunctionGraphExecutionOutputOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionOutputSelect>;
+} & Omit<UseQueryOptions<{
+    functionGraphExecutionOutputs: ConnectionResult<InferSelectResult<FunctionGraphExecutionOutputWithRelations, S>>;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ *
+ * @example
+ * ```ts
+ * const data = await fetchFunctionGraphExecutionOutputsQuery({
+ *   selection: {
+ *     fields: { id: true },
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function fetchFunctionGraphExecutionOutputsQuery<S extends FunctionGraphExecutionOutputSelect>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphExecutionOutputFilter, FunctionGraphExecutionOutputOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionOutputSelect>;
+}): Promise<{
+    functionGraphExecutionOutputs: ConnectionResult<InferSelectResult<FunctionGraphExecutionOutputWithRelations, S>>;
+}>;
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ *
+ * @example
+ * ```ts
+ * await prefetchFunctionGraphExecutionOutputsQuery(queryClient, { selection: { fields: { id: true }, first: 10 } });
+ * ```
+ */
+export declare function prefetchFunctionGraphExecutionOutputsQuery<S extends FunctionGraphExecutionOutputSelect>(queryClient: QueryClient, params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphExecutionOutputFilter, FunctionGraphExecutionOutputOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionOutputSelect>;
+}): Promise<void>;

package/esm/compute/hooks/queries/useFunctionGraphExecutionOutputsQuery.js

@@ -0,0 +1,32 @@
+/**
+ * Content-addressed store for execution outputs — hash-referenced from node_outputs
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildListSelectionArgs } from '../selection';
+import { functionGraphExecutionOutputKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const functionGraphExecutionOutputsQueryKey = functionGraphExecutionOutputKeys.list;
+export function useFunctionGraphExecutionOutputsQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: functionGraphExecutionOutputKeys.list(args),
+        queryFn: () => getClient().functionGraphExecutionOutput.findMany(args).unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchFunctionGraphExecutionOutputsQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    return getClient().functionGraphExecutionOutput.findMany(args).unwrap();
+}
+export async function prefetchFunctionGraphExecutionOutputsQuery(queryClient, params) {
+    const args = buildListSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: functionGraphExecutionOutputKeys.list(args),
+        queryFn: () => getClient().functionGraphExecutionOutput.findMany(args).unwrap(),
+    });
+}

package/esm/compute/hooks/queries/useFunctionGraphExecutionQuery.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Ephemeral execution state for flow graph evaluation
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { FunctionGraphExecutionSelect, FunctionGraphExecutionWithRelations } from '../../orm/input-types';
+import type { InferSelectResult, HookStrictSelect } from '../../orm/select-types';
+export type { FunctionGraphExecutionSelect, FunctionGraphExecutionWithRelations, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const functionGraphExecutionQueryKey: (id: string | number) => readonly ["functiongraphexecution", "detail", string | number];
+/**
+ * Ephemeral execution state for flow graph evaluation
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFunctionGraphExecutionQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true, name: true } },
+ * });
+ * ```
+ */
+export declare function useFunctionGraphExecutionQuery<S extends FunctionGraphExecutionSelect, TData = {
+    functionGraphExecution: InferSelectResult<FunctionGraphExecutionWithRelations, S> | null;
+}>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionSelect>;
+} & Omit<UseQueryOptions<{
+    functionGraphExecution: InferSelectResult<FunctionGraphExecutionWithRelations, S> | null;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Ephemeral execution state for flow graph evaluation
+ *
+ * @example
+ * ```ts
+ * const data = await fetchFunctionGraphExecutionQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true } },
+ * });
+ * ```
+ */
+export declare function fetchFunctionGraphExecutionQuery<S extends FunctionGraphExecutionSelect>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionSelect>;
+}): Promise<{
+    functionGraphExecution: InferSelectResult<FunctionGraphExecutionWithRelations, S> | null;
+}>;
+/**
+ * Ephemeral execution state for flow graph evaluation
+ *
+ * @example
+ * ```ts
+ * await prefetchFunctionGraphExecutionQuery(queryClient, { id: 'some-id', selection: { fields: { id: true } } });
+ * ```
+ */
+export declare function prefetchFunctionGraphExecutionQuery<S extends FunctionGraphExecutionSelect>(queryClient: QueryClient, params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionSelect>;
+}): Promise<void>;

package/esm/compute/hooks/queries/useFunctionGraphExecutionQuery.js

@@ -0,0 +1,47 @@
+/**
+ * Ephemeral execution state for flow graph evaluation
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildSelectionArgs } from '../selection';
+import { functionGraphExecutionKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const functionGraphExecutionQueryKey = functionGraphExecutionKeys.detail;
+export function useFunctionGraphExecutionQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: functionGraphExecutionKeys.detail(params.id),
+        queryFn: () => getClient()
+            .functionGraphExecution.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchFunctionGraphExecutionQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    return getClient()
+        .functionGraphExecution.findOne({
+        id: params.id,
+        select: args.select,
+    })
+        .unwrap();
+}
+export async function prefetchFunctionGraphExecutionQuery(queryClient, params) {
+    const args = buildSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: functionGraphExecutionKeys.detail(params.id),
+        queryFn: () => getClient()
+            .functionGraphExecution.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+    });
+}

package/esm/compute/hooks/queries/useFunctionGraphExecutionsQuery.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Ephemeral execution state for flow graph evaluation
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { ListSelectionConfig } from '../selection';
+import type { FunctionGraphExecutionSelect, FunctionGraphExecutionWithRelations, FunctionGraphExecutionFilter, FunctionGraphExecutionOrderBy } from '../../orm/input-types';
+import type { InferSelectResult, ConnectionResult, HookStrictSelect } from '../../orm/select-types';
+export type { FunctionGraphExecutionSelect, FunctionGraphExecutionWithRelations, FunctionGraphExecutionFilter, FunctionGraphExecutionOrderBy, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const functionGraphExecutionsQueryKey: (variables?: object) => readonly ["functiongraphexecution", "list", object];
+/**
+ * Ephemeral execution state for flow graph evaluation
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFunctionGraphExecutionsQuery({
+ *   selection: {
+ *     fields: { id: true, name: true },
+ *     where: { name: { equalTo: "example" } },
+ *     orderBy: ['CREATED_AT_DESC'],
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function useFunctionGraphExecutionsQuery<S extends FunctionGraphExecutionSelect, TData = {
+    functionGraphExecutions: ConnectionResult<InferSelectResult<FunctionGraphExecutionWithRelations, S>>;
+}>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphExecutionFilter, FunctionGraphExecutionOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionSelect>;
+} & Omit<UseQueryOptions<{
+    functionGraphExecutions: ConnectionResult<InferSelectResult<FunctionGraphExecutionWithRelations, S>>;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Ephemeral execution state for flow graph evaluation
+ *
+ * @example
+ * ```ts
+ * const data = await fetchFunctionGraphExecutionsQuery({
+ *   selection: {
+ *     fields: { id: true },
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function fetchFunctionGraphExecutionsQuery<S extends FunctionGraphExecutionSelect>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphExecutionFilter, FunctionGraphExecutionOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionSelect>;
+}): Promise<{
+    functionGraphExecutions: ConnectionResult<InferSelectResult<FunctionGraphExecutionWithRelations, S>>;
+}>;
+/**
+ * Ephemeral execution state for flow graph evaluation
+ *
+ * @example
+ * ```ts
+ * await prefetchFunctionGraphExecutionsQuery(queryClient, { selection: { fields: { id: true }, first: 10 } });
+ * ```
+ */
+export declare function prefetchFunctionGraphExecutionsQuery<S extends FunctionGraphExecutionSelect>(queryClient: QueryClient, params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphExecutionFilter, FunctionGraphExecutionOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphExecutionSelect>;
+}): Promise<void>;

package/esm/compute/hooks/queries/useFunctionGraphExecutionsQuery.js

@@ -0,0 +1,32 @@
+/**
+ * Ephemeral execution state for flow graph evaluation
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildListSelectionArgs } from '../selection';
+import { functionGraphExecutionKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const functionGraphExecutionsQueryKey = functionGraphExecutionKeys.list;
+export function useFunctionGraphExecutionsQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: functionGraphExecutionKeys.list(args),
+        queryFn: () => getClient().functionGraphExecution.findMany(args).unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchFunctionGraphExecutionsQuery(params) {
+    const args = buildListSelectionArgs(params.selection);
+    return getClient().functionGraphExecution.findMany(args).unwrap();
+}
+export async function prefetchFunctionGraphExecutionsQuery(queryClient, params) {
+    const args = buildListSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: functionGraphExecutionKeys.list(args),
+        queryFn: () => getClient().functionGraphExecution.findMany(args).unwrap(),
+    });
+}

package/esm/compute/hooks/queries/useFunctionGraphObjectQuery.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { FunctionGraphObjectSelect, FunctionGraphObjectWithRelations } from '../../orm/input-types';
+import type { InferSelectResult, HookStrictSelect } from '../../orm/select-types';
+export type { FunctionGraphObjectSelect, FunctionGraphObjectWithRelations, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const getNodeAtPathQueryKey: (id: string | number) => readonly ["functiongraphobject", "detail", string | number];
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFunctionGraphObjectQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true, name: true } },
+ * });
+ * ```
+ */
+export declare function useFunctionGraphObjectQuery<S extends FunctionGraphObjectSelect, TData = {
+    getNodeAtPath: InferSelectResult<FunctionGraphObjectWithRelations, S> | null;
+}>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphObjectSelect>;
+} & Omit<UseQueryOptions<{
+    getNodeAtPath: InferSelectResult<FunctionGraphObjectWithRelations, S> | null;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ *
+ * @example
+ * ```ts
+ * const data = await fetchFunctionGraphObjectQuery({
+ *   id: 'some-id',
+ *   selection: { fields: { id: true } },
+ * });
+ * ```
+ */
+export declare function fetchFunctionGraphObjectQuery<S extends FunctionGraphObjectSelect>(params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphObjectSelect>;
+}): Promise<{
+    getNodeAtPath: InferSelectResult<FunctionGraphObjectWithRelations, S> | null;
+}>;
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ *
+ * @example
+ * ```ts
+ * await prefetchFunctionGraphObjectQuery(queryClient, { id: 'some-id', selection: { fields: { id: true } } });
+ * ```
+ */
+export declare function prefetchFunctionGraphObjectQuery<S extends FunctionGraphObjectSelect>(queryClient: QueryClient, params: {
+    id: string;
+    selection: {
+        fields: S;
+    } & HookStrictSelect<NoInfer<S>, FunctionGraphObjectSelect>;
+}): Promise<void>;

package/esm/compute/hooks/queries/useFunctionGraphObjectQuery.js

@@ -0,0 +1,47 @@
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../client';
+import { buildSelectionArgs } from '../selection';
+import { functionGraphObjectKeys } from '../query-keys';
+/** Query key factory - re-exported from query-keys.ts */
+export const getNodeAtPathQueryKey = functionGraphObjectKeys.detail;
+export function useFunctionGraphObjectQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    const { selection: _selection, ...queryOptions } = params ?? {};
+    void _selection;
+    return useQuery({
+        queryKey: functionGraphObjectKeys.detail(params.id),
+        queryFn: () => getClient()
+            .functionGraphObject.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+        ...queryOptions,
+    });
+}
+export async function fetchFunctionGraphObjectQuery(params) {
+    const args = buildSelectionArgs(params.selection);
+    return getClient()
+        .functionGraphObject.findOne({
+        id: params.id,
+        select: args.select,
+    })
+        .unwrap();
+}
+export async function prefetchFunctionGraphObjectQuery(queryClient, params) {
+    const args = buildSelectionArgs(params.selection);
+    await queryClient.prefetchQuery({
+        queryKey: functionGraphObjectKeys.detail(params.id),
+        queryFn: () => getClient()
+            .functionGraphObject.findOne({
+            id: params.id,
+            select: args.select,
+        })
+            .unwrap(),
+    });
+}

package/esm/compute/hooks/queries/useFunctionGraphObjectsQuery.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import type { UseQueryOptions, UseQueryResult, QueryClient } from '@tanstack/react-query';
+import type { ListSelectionConfig } from '../selection';
+import type { FunctionGraphObjectSelect, FunctionGraphObjectWithRelations, FunctionGraphObjectFilter, FunctionGraphObjectOrderBy } from '../../orm/input-types';
+import type { InferSelectResult, ConnectionResult, HookStrictSelect } from '../../orm/select-types';
+export type { FunctionGraphObjectSelect, FunctionGraphObjectWithRelations, FunctionGraphObjectFilter, FunctionGraphObjectOrderBy, } from '../../orm/input-types';
+/** Query key factory - re-exported from query-keys.ts */
+export declare const functionGraphObjectsQueryKey: (variables?: object) => readonly ["functiongraphobject", "list", object];
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useFunctionGraphObjectsQuery({
+ *   selection: {
+ *     fields: { id: true, name: true },
+ *     where: { name: { equalTo: "example" } },
+ *     orderBy: ['CREATED_AT_DESC'],
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function useFunctionGraphObjectsQuery<S extends FunctionGraphObjectSelect, TData = {
+    functionGraphObjects: ConnectionResult<InferSelectResult<FunctionGraphObjectWithRelations, S>>;
+}>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphObjectFilter, FunctionGraphObjectOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphObjectSelect>;
+} & Omit<UseQueryOptions<{
+    functionGraphObjects: ConnectionResult<InferSelectResult<FunctionGraphObjectWithRelations, S>>;
+}, Error, TData>, 'queryKey' | 'queryFn'>): UseQueryResult<TData>;
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ *
+ * @example
+ * ```ts
+ * const data = await fetchFunctionGraphObjectsQuery({
+ *   selection: {
+ *     fields: { id: true },
+ *     first: 10,
+ *   },
+ * });
+ * ```
+ */
+export declare function fetchFunctionGraphObjectsQuery<S extends FunctionGraphObjectSelect>(params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphObjectFilter, FunctionGraphObjectOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphObjectSelect>;
+}): Promise<{
+    functionGraphObjects: ConnectionResult<InferSelectResult<FunctionGraphObjectWithRelations, S>>;
+}>;
+/**
+ * Content-addressed Merkle tree objects keyed by UUID v5 hash of data + children
+ *
+ * @example
+ * ```ts
+ * await prefetchFunctionGraphObjectsQuery(queryClient, { selection: { fields: { id: true }, first: 10 } });
+ * ```
+ */
+export declare function prefetchFunctionGraphObjectsQuery<S extends FunctionGraphObjectSelect>(queryClient: QueryClient, params: {
+    selection: {
+        fields: S;
+    } & Omit<ListSelectionConfig<S, FunctionGraphObjectFilter, FunctionGraphObjectOrderBy>, 'fields'> & HookStrictSelect<NoInfer<S>, FunctionGraphObjectSelect>;
+}): Promise<void>;