@chelone/vue 0.0.0-stage → 0.1.1

package/dist/data/mutations.d.ts

@@ -0,0 +1,521 @@
+/**
+ * Data-mutation composables over `@tanstack/vue-query` — the Vue twin of the
+ * mutation half of `@chelone/react`'s `hooks.ts` (`useUpdate` / `useDelete` +
+ * the bulk pair). Wraps core's framework-agnostic `updateMutationOptions` /
+ * `deleteMutationOptions` (`mutationFn` + cache invalidation) and hands it to
+ * vue-query's `useMutation`, reusing the SAME `dataProvider` + `queryClient`
+ * `<Admin>` provides. `<ApiKeyInput>` is the first consumer: it is NOT form-bound
+ * — it reads the ambient record/resource and dispatches this mutation directly
+ * to trigger a server-side key rotation.
+ *
+ * R3: each composable honors `options.mutationMode: "undoable"` by swapping its
+ * `mutate` / `mutateAsync` for the optimistic-with-Undo flow (apply the cache
+ * change now, defer the dataProvider call until the Undo window closes) via the
+ * vanilla `startUndoableMutation` engine + an Undo notification. The default
+ * (`"pessimistic"`) path is unchanged.
+ */
+import { type DeleteManyParams, type DeleteParams, type Identifier, type MutationModeOptions, type RecordOf, type ResourceMap, type UndoableCallbacks, type UndoableUpdateManyCallbacks, type UpdateManyParams, type UpdateParams } from "@chelone/core";
+/**
+ * A mutation whose `mutate` / `mutateAsync` are swapped for the undoable pair,
+ * the state refs untouched. Naming it keeps the hook's inferred type
+ * declaration-emittable: spreading vue-query's refs over a generic record type
+ * would expand to `@vue/shared` types a `.d.ts` cannot name.
+ */
+type Undoable<TMutation, TParams, TData> = Omit<TMutation, "mutate" | "mutateAsync"> & {
+    mutate: (params: TParams, callbacks?: UndoableCallbacks<TData, TParams>) => void;
+    mutateAsync: (params: TParams) => Promise<void>;
+};
+/**
+ * Create mutation for `resource` — the Vue twin of `@chelone/react`'s
+ * `useCreate(resource)`. Call `.mutateAsync({ data })` to dispatch; the
+ * resource's caches are invalidated on settle. Takes no mutation mode (create
+ * has no record to patch optimistically), as React's does not.
+ */
+export declare function useCreate<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName): import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<RecordOf<TResources, TName>>, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, Error, import("@chelone/core").CreateParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>;
+/**
+ * Update-one mutation for `resource`. Returns vue-query's mutation object; call
+ * `.mutateAsync({ id, data, previousData })` to dispatch. Mirrors the React
+ * `useUpdate(resource)` — `updateMutationOptions` binds the resource at call
+ * time and invalidates that resource's caches on settle.
+ */
+export declare function useUpdate<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">> | Undoable<import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">>, UpdateParams<RecordOf<TResources, TName>>, RecordOf<TResources, TName>>;
+/**
+ * Delete-one mutation for `resource`. Returns vue-query's mutation object; call
+ * `.mutateAsync({ id, previousData })` to dispatch. Mirrors the React delete
+ * stack — `deleteMutationOptions` binds the resource at call time and
+ * invalidates that resource's caches on settle. `<DeleteButton>` is the first
+ * consumer: it dispatches this on confirm, then redirects + notifies itself
+ * (chelone has no baked-in delete controller yet — see the button's header).
+ */
+export declare function useDelete<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">> | Undoable<import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">>, DeleteParams<RecordOf<TResources, TName>>, RecordOf<TResources, TName> | undefined>;
+/**
+ * Delete-many mutation for `resource` — the Vue twin of the bulk delete path
+ * `@chelone/react`'s `<BulkDeleteButton>` fires against
+ * `dataProvider.deleteMany`. Core carries NO `deleteManyMutationOptions` (there
+ * is no bulk mutation-options helper), so this wraps `dataProvider.deleteMany`
+ * itself and invalidates the resource's caches on settle (the same
+ * `resourceKey` scope core's single-record helpers invalidate). Call
+ * `.mutateAsync({ ids })` to dispatch; `<BulkDeleteButton>` then clears the
+ * selection + notifies. `options.mutationMode: "undoable"` swaps `mutate` /
+ * `mutateAsync` for the optimistic-with-Undo flow (remove the rows now, defer the
+ * server call until the Undo window closes) via the core `startUndoableMutation`.
+ */
+export declare function useDeleteMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"idle", "idle">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<undefined, undefined>;
+    isIdle: import("vue").Ref<true, true>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"pending", "pending">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<Error, Error>;
+    status: import("vue").Ref<"error", "error">;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<Identifier[], Identifier[]>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"success", "success">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+};
+/**
+ * Update-many mutation for `resource` — the Vue twin of the bulk update path
+ * `@chelone/react`'s `<BulkUpdateButton>` fires against
+ * `dataProvider.updateMany`. Like {@link useDeleteMany}, core has no bulk
+ * mutation-options helper, so this wraps `dataProvider.updateMany` itself and
+ * invalidates the resource's caches on settle. Call `.mutateAsync({ ids, data })`
+ * to dispatch; `<BulkUpdateButton>` then clears the selection + notifies.
+ */
+export declare function useUpdateMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"idle", "idle">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<undefined, undefined>;
+    isIdle: import("vue").Ref<true, true>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"pending", "pending">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<Error, Error>;
+    status: import("vue").Ref<"error", "error">;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<Identifier[], Identifier[]>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"success", "success">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+};
+export {};

package/dist/data/mutations.js

@@ -0,0 +1,127 @@
+import { updateMutationOptions, resourceKey, createMutationOptions, deleteMutationOptions, undoableCallbacks, undoableUpdateOptions, patchedRecord, undoableDeleteOptions } from "@chelone/core";
+import { useMutation } from "@tanstack/vue-query";
+import { useCheloneContext } from "../context.js";
+import { useUndoable } from "./undoable.js";
+function useCreate(resource) {
+  const ctx = useCheloneContext();
+  return useMutation(createMutationOptions(ctx, resource));
+}
+function useUpdate(resource, options = {}) {
+  const ctx = useCheloneContext();
+  const runUndoable = useUndoable();
+  const mutation = useMutation(updateMutationOptions(ctx, resource, options));
+  if (options.mutationMode !== "undoable") return mutation;
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
+    runUndoable({
+      ...undoableUpdateOptions(
+        ctx.queryClient,
+        resource,
+        [params.id],
+        params.data
+      ),
+      commit: settle.commit(() => ctx.dataProvider.update(resource, params))
+    });
+    settle.success(patchedRecord(params));
+  };
+  const undoable = {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+  return undoable;
+}
+function useDelete(resource, options = {}) {
+  const ctx = useCheloneContext();
+  const runUndoable = useUndoable();
+  const mutation = useMutation(deleteMutationOptions(ctx, resource, options));
+  if (options.mutationMode !== "undoable") return mutation;
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
+    runUndoable({
+      ...undoableDeleteOptions(ctx.queryClient, resource, [params.id]),
+      commit: settle.commit(() => ctx.dataProvider.delete(resource, params))
+    });
+    settle.success(params.previousData);
+  };
+  const undoable = {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+  return undoable;
+}
+function useDeleteMany(resource, options = {}) {
+  const ctx = useCheloneContext();
+  const runUndoable = useUndoable();
+  const mutation = useMutation({
+    mutationFn: async (params) => {
+      const result = await ctx.dataProvider.deleteMany(resource, params);
+      return result.data;
+    },
+    onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
+  });
+  if (options.mutationMode !== "undoable") return mutation;
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
+    runUndoable({
+      ...undoableDeleteOptions(ctx.queryClient, resource, params.ids),
+      commit: settle.commit(
+        () => ctx.dataProvider.deleteMany(resource, params)
+      )
+    });
+    settle.success(params.ids);
+  };
+  return {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+}
+function useUpdateMany(resource, options = {}) {
+  const ctx = useCheloneContext();
+  const runUndoable = useUndoable();
+  const mutation = useMutation({
+    mutationFn: async (params) => {
+      const result = await ctx.dataProvider.updateMany(resource, params);
+      return result.data;
+    },
+    onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
+  });
+  if (options.mutationMode !== "undoable") return mutation;
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
+    runUndoable({
+      ...undoableUpdateOptions(
+        ctx.queryClient,
+        resource,
+        params.ids,
+        params.data
+      ),
+      commit: settle.commit(
+        () => ctx.dataProvider.updateMany(resource, params)
+      )
+    });
+    settle.success(params.ids);
+  };
+  return {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+}
+export {
+  useCreate,
+  useDelete,
+  useDeleteMany,
+  useUpdate,
+  useUpdateMany
+};