@mobx-query/core 0.2.2 → 0.2.4

package/dist/entity/Entity.d.ts

@@ -0,0 +1,31 @@
+import { EntityData, EntityEvents, EntityId } from './types';
+import { MQClientAccessor } from '../client';
+import { EntityState } from './constants';
+export type EntityConstructor<TData = unknown, TEntityId extends EntityId = string, E extends Entity<TData, TEntityId> = Entity<TData, TEntityId>> = new () => E;
+export type EntityConstructorAny = EntityConstructor<EntityData, any, EntityAny>;
+export type EntityAny = Entity<any, any>;
+export type EntityValueKeys<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K extends "isDirty" | "state" | "queryHashes" ? never : K;
+}[keyof T] & string;
+export declare abstract class Entity<TData = unknown, TEntityId extends EntityId = string> extends MQClientAccessor {
+    abstract id: TEntityId;
+    abstract hydrate(data: TData): void;
+    readonly queryHashes: Set<string>;
+    private events;
+    accessor state: EntityState;
+    accessor isDirty: boolean;
+    private readonly initValuesSnapshot;
+    private isHydrated;
+    _init(queryHashes: string[], events: EntityEvents<TEntityId>): void;
+    _removeQueryHashes(hashes: string[]): void;
+    _markAsHydrated(): void;
+    private onObservableChange;
+    /**
+     * Deep clones a value to ensure we store a snapshot, not a reference.
+     * Handles primitives, objects, arrays, and MobX observables.
+     */
+    private deepCloneValue;
+    reset(): void;
+    _clearDirty(): void;
+    invalidateRelatedQueries(): void;
+}

package/dist/entity/EntityCollection.d.ts

@@ -0,0 +1,29 @@
+import { EntityConstructor, EntityConstructorAny } from './Entity';
+import { QueryClient } from '@tanstack/react-query';
+import { EntityDataAny, EntityId } from './types';
+export declare class EntityCollection<TEntityConstructor extends EntityConstructorAny = EntityConstructorAny> {
+    private readonly entityConstructor;
+    private readonly queryClient;
+    accessor collection: Map<EntityId, InstanceType<TEntityConstructor>>;
+    accessor deletedRecordIds: Set<EntityId>;
+    accessor clientOnlyEntityIds: Set<EntityId>;
+    constructor(entityConstructor: EntityConstructor<any, any, InstanceType<TEntityConstructor>>, queryClient: QueryClient);
+    get size(): number;
+    get entities(): InstanceType<TEntityConstructor>[];
+    get clientOnlyEntitiesMap(): Map<EntityId, InstanceType<TEntityConstructor>>;
+    get clientOnlyEntities(): InstanceType<TEntityConstructor>[];
+    setEntity(data: EntityDataAny, queryHashes?: string[]): InstanceType<TEntityConstructor>;
+    setEntities(entityData: EntityDataAny[], queryHashes: string[]): readonly [InstanceType<TEntityConstructor>[], EntityId[]];
+    deleteEntity(entityId: EntityId): void;
+    getEntityById(entityId: EntityId): InstanceType<TEntityConstructor> | undefined;
+    filter(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): InstanceType<TEntityConstructor>[];
+    find(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): InstanceType<TEntityConstructor> | undefined;
+    findIndex(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): number;
+    findLast(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): InstanceType<TEntityConstructor> | undefined;
+    findLastIndex(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): number;
+    some(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): boolean;
+    every(predicate: (value: InstanceType<TEntityConstructor>, index: number) => boolean): boolean;
+    map<T>(predicate: (value: InstanceType<TEntityConstructor>, index: number) => T): T[];
+    private initQueryClientCacheListener;
+    private removeQueryHashesFromAllEntities;
+}

package/dist/entity/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const EntityState: {
+    readonly PENDING: "pending";
+    readonly CONFIRMED: "confirmed";
+    readonly FAILED: "failed";
+};
+export type EntityState = (typeof EntityState)[keyof typeof EntityState];

package/dist/entity/index.d.ts

@@ -0,0 +1,6 @@
+import { Entity, EntityConstructorAny, EntityAny } from './Entity';
+import { EntityCollection } from './EntityCollection';
+import { EntityState } from './constants';
+import { EntityId, EntityData, EntityDataAny } from './types';
+export { Entity, EntityState, EntityCollection };
+export type { EntityConstructorAny, EntityAny, EntityData, EntityDataAny, EntityId, };

package/{src/libs/mobx-query/entity/types.ts → dist/entity/types.d.ts}

@@ -1,11 +1,8 @@
-export type EntityId = string | number;
-
-export interface EntityData<TEntityId extends EntityId = string> {
-  id: TEntityId;
-}
-
-export type EntityDataAny = EntityData<EntityId>;
-
-export interface EntityEvents<TEntityId extends EntityId = string> {
-  onAllQueryHashesRemoved: (entityId: TEntityId) => void;
-}
+export type EntityId = string | number;
+export interface EntityData<TEntityId extends EntityId = string> {
+    id: TEntityId;
+}
+export type EntityDataAny = EntityData<EntityId>;
+export interface EntityEvents<TEntityId extends EntityId = string> {
+    onAllQueryHashesRemoved: (entityId: TEntityId) => void;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './client';
+export * from './entity';
+export * from './mutations';
+export * from './queries';
+export * from './react';
+export * from './utils';

package/dist/mutations/BatchMutationBase.d.ts

@@ -0,0 +1,14 @@
+import { DefaultError, MutationFunctionContext } from '@tanstack/react-query';
+import { EntityConstructorAny, EntityCollection } from '../entity';
+import { BatchMutationInputInternal, UseBatchMutationHookOptions } from './types';
+import { MutationBase } from './MutationBase';
+export declare class BatchMutationBase<TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown> extends MutationBase<TEntityConstructor> {
+    protected readonly options: UseBatchMutationHookOptions<TEntityConstructor, TError, TMutateResult>;
+    protected readonly collection: EntityCollection<TEntityConstructor>;
+    constructor(mutationPrefix: string, options: UseBatchMutationHookOptions<TEntityConstructor, TError, TMutateResult>);
+    protected onMutateBase(input: BatchMutationInputInternal<TEntityConstructor>, context: MutationFunctionContext): Promise<TMutateResult>;
+    protected onSuccessBase(input: BatchMutationInputInternal<TEntityConstructor>, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext): Promise<void>;
+    protected onErrorBase(error: TError, input: BatchMutationInputInternal<TEntityConstructor>, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext): Promise<void>;
+    protected onSettledBase(error: TError | null, input: BatchMutationInputInternal<TEntityConstructor>, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext): Promise<void>;
+    protected createInternalInput(entities: InstanceType<TEntityConstructor>[]): BatchMutationInputInternal<TEntityConstructor>;
+}

package/dist/mutations/BatchUpdateMutation.d.ts

@@ -0,0 +1,9 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { BatchMutationBase } from './BatchMutationBase';
+import { UseBatchMutationHookOptions } from './types';
+export declare class BatchUpdateMutation<TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown> extends BatchMutationBase<TEntityConstructor, TError, TMutateResult> {
+    static readonly mutationPrefix = "__mutation__batch__update__";
+    constructor(options: UseBatchMutationHookOptions<TEntityConstructor, TError, TMutateResult>);
+    useMutation(): (entities: InstanceType<TEntityConstructor>[]) => void;
+}

package/dist/mutations/CreateMutation.d.ts

@@ -0,0 +1,15 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityAny, EntityConstructorAny } from '../entity';
+import { UseCreateMutationHookOptions } from './types';
+import { MutationBase } from './MutationBase';
+export declare class CreateMutation<TInput, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError = DefaultError, TMutateResult = unknown> extends MutationBase<TEntityConstructor> {
+    private readonly options;
+    static readonly mutationPrefix = "__mutation__create__";
+    constructor(options: UseCreateMutationHookOptions<TInput, TEntityConstructor, TError, TMutateResult>);
+    useMutation(): (input: TInput) => void;
+    private onMutate;
+    private onSuccess;
+    private onError;
+    private onSettled;
+    protected createMutationStrategy(entities: EntityAny[]): import('./OptimisticMutationStrategy').OptimisticMutationStrategy;
+}

package/dist/mutations/DeleteMutation.d.ts

@@ -0,0 +1,14 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { UseEntityMutationHookOptions } from './types';
+import { EntityMutationBase } from './EntityMutationBase';
+export declare class DeleteMutation<TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown> extends EntityMutationBase<void, TEntityConstructor, TError, TMutateResult> {
+    static readonly mutationPrefix = "__mutation__delete__";
+    constructor(options: UseEntityMutationHookOptions<TEntityConstructor, TError, TMutateResult>);
+    useMutation(): () => void;
+    private onMutate;
+    private onSuccess;
+    private onError;
+    private onSettled;
+    mutate(input: void): void;
+}

package/dist/mutations/EntityMutationBase.d.ts

@@ -0,0 +1,22 @@
+import { EntityConstructorAny, EntityAny } from '../entity';
+import { OptimisticMutationStrategy } from './OptimisticMutationStrategy';
+import { EntityMutationCallbacks, UseEntityMutationHookOptions } from './types';
+import { DefaultError, MutationFunctionContext } from '@tanstack/react-query';
+import { MutationBase } from './MutationBase';
+/**
+ * Base class for mutations that operate ON an existing entity.
+ * Use this for update/delete mutations where the entity already exists.
+ * For entity-creating mutations, use CollectionMutationBase instead.
+ */
+export declare abstract class EntityMutationBase<TInput, TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown> extends MutationBase<TEntityConstructor> {
+    protected readonly options: UseEntityMutationHookOptions<TEntityConstructor, TError, TMutateResult>;
+    protected readonly mutationStrategy: OptimisticMutationStrategy;
+    constructor(mutationPrefix: string, options: UseEntityMutationHookOptions<TEntityConstructor, TError, TMutateResult>);
+    get entityMutationKey(): any[];
+    protected onMutateBase(context: MutationFunctionContext): Promise<TMutateResult | undefined>;
+    protected onSuccessBase(result: TMutateResult | undefined, ctx: MutationFunctionContext): Promise<void>;
+    protected onErrorBase(error: TError, result: TMutateResult | undefined, ctx: MutationFunctionContext): Promise<void>;
+    protected onSettledBase(error: TError | null, result: TMutateResult | undefined, ctx: MutationFunctionContext): Promise<void>;
+    protected mutateBase(input: TInput, callbacks: EntityMutationCallbacks<EntityAny, TError, TMutateResult>): void;
+    abstract mutate(input: TInput): void;
+}

package/dist/mutations/MutationBase.d.ts

@@ -0,0 +1,13 @@
+import { EntityAny, EntityConstructorAny } from '../entity';
+import { EntityCollection } from '../entity/EntityCollection';
+import { MQClientAccessor } from '../client';
+import { OptimisticMutationStrategy } from './OptimisticMutationStrategy';
+import { OptimisticMutationStrategyOptions } from './types';
+export declare class MutationBase<TEntityConstructor extends EntityConstructorAny> extends MQClientAccessor {
+    protected readonly mutationPrefix: string;
+    protected readonly entity: TEntityConstructor;
+    protected readonly collection: EntityCollection<TEntityConstructor>;
+    constructor(mutationPrefix: string, entity: TEntityConstructor);
+    get baseMutationKey(): string[];
+    protected createMutationStrategy(entities: EntityAny[], options: OptimisticMutationStrategyOptions): OptimisticMutationStrategy;
+}

package/dist/mutations/OptimisticMutationStrategy.d.ts

@@ -0,0 +1,19 @@
+import { EntityConstructorAny, EntityAny } from '../entity';
+import { OptimisticMutationStrategyOptions } from './types';
+import { MQClientAccessor } from '../client';
+import { OptimisticMutationErrorStrategy, OptimisticMutationInvalidationStrategy } from './constants';
+export declare class OptimisticMutationStrategy extends MQClientAccessor {
+    private readonly entityConstructor;
+    private readonly entities;
+    private readonly options?;
+    constructor(entityConstructor: EntityConstructorAny, entities: EntityAny[], options?: OptimisticMutationStrategyOptions | undefined);
+    get invalidationStrategy(): OptimisticMutationInvalidationStrategy;
+    get mutationErrorStrategy(): OptimisticMutationErrorStrategy;
+    get invalidateOnError(): boolean;
+    onMutate(): void;
+    onSuccess(): void;
+    onError(ignoreReset?: boolean): void;
+    private runInvalidationStrategy;
+    private invalidateCollectionRelatedQueries;
+    private invalidateEntityRelatedQueries;
+}

package/dist/mutations/UpdateMutation.d.ts

@@ -0,0 +1,10 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { UseEntityMutationHookOptions } from './types';
+import { EntityMutationBase } from './EntityMutationBase';
+export declare class UpdateMutation<TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown> extends EntityMutationBase<void, TEntityConstructor, TError, TMutateResult> {
+    static readonly mutationPrefix = "__mutation__update__";
+    constructor(options: UseEntityMutationHookOptions<TEntityConstructor, TError, TMutateResult>);
+    useMutation(): () => void;
+    mutate(input: void): void;
+}

package/dist/mutations/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const OptimisticMutationInvalidationStrategy: {
+    readonly ALL_QUERIES: "all-queries";
+    readonly ALL_ENTITY_QUERIES: "all-entity-queries";
+    readonly REFERENCED_QUERIES: "referenced-queries";
+    readonly NONE: "none";
+};
+export declare const OptimisticMutationErrorStrategy: {
+    readonly ROLLBACK: "rollback";
+    readonly KEEP: "keep";
+};
+export type OptimisticMutationInvalidationStrategy = (typeof OptimisticMutationInvalidationStrategy)[keyof typeof OptimisticMutationInvalidationStrategy];
+export type OptimisticMutationErrorStrategy = (typeof OptimisticMutationErrorStrategy)[keyof typeof OptimisticMutationErrorStrategy];

package/dist/mutations/index.d.ts

@@ -0,0 +1,11 @@
+import { MutationFn, BatchMutationFn, CreateMutationFn, OptimisticMutationStrategyOptions, UseCreateMutationHookOptions, UseEntityMutationHookOptions, UseBatchMutationHookOptions } from './types';
+import { BatchMutationBase } from './BatchMutationBase';
+import { BatchUpdateMutation } from './BatchUpdateMutation';
+import { CreateMutation } from './CreateMutation';
+import { DeleteMutation } from './DeleteMutation';
+import { EntityMutationBase } from './EntityMutationBase';
+import { UpdateMutation } from './UpdateMutation';
+import { MutationBase } from './MutationBase';
+import { OptimisticMutationErrorStrategy, OptimisticMutationInvalidationStrategy } from './constants';
+export { MutationBase, BatchMutationBase, EntityMutationBase, BatchUpdateMutation, CreateMutation, DeleteMutation, UpdateMutation, OptimisticMutationErrorStrategy, OptimisticMutationInvalidationStrategy, };
+export type { MutationFn, BatchMutationFn, CreateMutationFn, OptimisticMutationStrategyOptions, UseCreateMutationHookOptions, UseEntityMutationHookOptions, UseBatchMutationHookOptions, };

package/dist/mutations/types.d.ts

@@ -0,0 +1,55 @@
+import { DefaultError, MutationFunctionContext, UseMutationOptions } from '@tanstack/react-query';
+import { MQClientContextRegistered } from '../client/types';
+import { EntityAny, EntityConstructorAny } from '../entity';
+import { OptimisticMutationStrategy } from './OptimisticMutationStrategy';
+import { OptimisticMutationErrorStrategy, OptimisticMutationInvalidationStrategy } from './constants';
+export type MutationFn<TInput> = (input: TInput, context: MQClientContextRegistered) => Promise<void>;
+export type BatchMutationFn<TEntity extends EntityAny> = (entities: TEntity[], context: MQClientContextRegistered) => Promise<void>;
+export interface CreateMutationInputInternal<TInput, TEntityConstructor extends EntityConstructorAny> {
+    input: TInput;
+    entity: InstanceType<TEntityConstructor>;
+    mutationStrategy: OptimisticMutationStrategy;
+}
+export interface BatchMutationInputInternal<TEntityConstructor extends EntityConstructorAny> {
+    strategy: OptimisticMutationStrategy;
+    entities: InstanceType<TEntityConstructor>[];
+}
+export interface OptimisticMutationStrategyOptions {
+    invalidationStrategy?: OptimisticMutationInvalidationStrategy;
+    errorStrategy?: OptimisticMutationErrorStrategy;
+    invalidateOnError?: boolean;
+}
+export interface UseMutationHookCommonOptions<TData = unknown, TError = DefaultError, TVariables = void, TMutateResult = unknown> extends Omit<UseMutationOptions<TData, TError, TVariables, TMutateResult>, "mutationFn" | "mutationKey" | "onSuccess" | "onError" | "onMutate" | "onSettled"> {
+}
+export interface UseCreateMutationHookOptions<TInput, TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown, TEntity extends InstanceType<TEntityConstructor> = InstanceType<TEntityConstructor>> extends UseMutationHookCommonOptions<void, TError, void, TMutateResult>, OptimisticMutationStrategyOptions, CreateEntityMutationCallbacks<TInput, TEntity, TError, TMutateResult> {
+    entity: TEntityConstructor;
+    mutationFn: CreateMutationFn<TInput, TEntityConstructor>;
+}
+export type CreateMutationFn<TInput, TEntityConstructor extends EntityConstructorAny> = (input: TInput, entity: InstanceType<TEntityConstructor>, context: MQClientContextRegistered) => Promise<void>;
+export interface CreateEntityMutationCallbacks<TInput, TEntity extends EntityAny, TError = DefaultError, TMutateResult = unknown> {
+    onMutate?: (input: TInput, entity: TEntity, context: MutationFunctionContext) => (TMutateResult | Promise<TMutateResult | undefined>) | undefined;
+    onSuccess?: (input: TInput, entity: TEntity, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext) => void | Promise<void>;
+    onError?: (error: TError, input: TInput, entity: TEntity, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext) => void | Promise<void>;
+    onSettled?: (input: TInput, entity: TEntity, error: TError | null, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext) => void | Promise<void>;
+}
+export interface EntityMutationCallbacks<TEntity extends EntityAny, TError = DefaultError, TMutateResult = unknown> {
+    onMutate?: (entity: TEntity, context: MutationFunctionContext) => (TMutateResult | Promise<TMutateResult | undefined>) | undefined;
+    onSuccess?: (entity: TEntity, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext) => void | Promise<void>;
+    onError?: (error: TError, entity: TEntity, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext) => void | Promise<void>;
+    onSettled?: (entity: TEntity, error: TError | null, onMutateResult: TMutateResult | undefined, context: MutationFunctionContext) => void | Promise<void>;
+}
+export interface UseEntityMutationHookOptions<TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown, TEntity extends InstanceType<TEntityConstructor> = InstanceType<TEntityConstructor>> extends UseMutationHookCommonOptions<void, TError, void, TMutateResult>, OptimisticMutationStrategyOptions, EntityMutationCallbacks<TEntity, TError, TMutateResult> {
+    entity: TEntityConstructor;
+    instance: TEntity;
+    mutationFn: MutationFn<void>;
+}
+export interface EntitiesBatchMutationCallbacks<TEntity extends EntityAny, TError = DefaultError, TMutateResult = unknown> {
+    onMutate?: (entities: TEntity[], context: MutationFunctionContext) => (TMutateResult | Promise<TMutateResult | undefined>) | undefined;
+    onSuccess?: (entities: TEntity[], context: MutationFunctionContext, onMutateResult: TMutateResult | undefined) => void | Promise<void>;
+    onError?: (error: TError, entities: TEntity[], context: MutationFunctionContext, onMutateResult: TMutateResult | undefined) => void | Promise<void>;
+    onSettled?: (entities: TEntity[], context: MutationFunctionContext, onMutateResult: TMutateResult | undefined, error: TError | null) => void | Promise<void>;
+}
+export interface UseBatchMutationHookOptions<TEntityConstructor extends EntityConstructorAny, TError = DefaultError, TMutateResult = unknown, TEntity extends EntityAny = InstanceType<TEntityConstructor>> extends UseMutationHookCommonOptions<void, TError, TEntity[], TMutateResult>, OptimisticMutationStrategyOptions, EntitiesBatchMutationCallbacks<TEntity, TError, TMutateResult> {
+    entity: TEntityConstructor;
+    mutationFn: BatchMutationFn<TEntity>;
+}

package/dist/queries/QueryBase.d.ts

@@ -0,0 +1,14 @@
+import { MQClientAccessor } from '../client';
+import { EntityConstructorAny, EntityDataAny } from '../entity';
+export declare abstract class QueryBase<TArguments = unknown> extends MQClientAccessor {
+    private readonly entityConstructors;
+    private readonly baseQueryKeysRest;
+    constructor(entityConstructors: EntityConstructorAny[], baseQueryKeysRest: () => unknown[]);
+    get baseQueryKey(): unknown[];
+    get baseQueryHash(): string;
+    protected createQueryKey(args: TArguments): unknown[];
+    protected createQueryHash(args: TArguments): string;
+    useIsFetching(args: TArguments): number;
+    protected setOneEntity(data: EntityDataAny, queryKey: unknown[], entityConstructor: EntityConstructorAny): import('..').EntityAny;
+    protected setManyEntities(data: EntityDataAny[], queryKey: unknown[], entityConstructor: EntityConstructorAny): readonly [import('..').EntityAny[], import('..').EntityId[]];
+}

package/dist/queries/QueryFragmentMany.d.ts

@@ -0,0 +1,9 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { UseQueryManyOptions } from './types';
+import { QueryManyBase } from './QueryManyBase';
+export declare class QueryFragmentMany<TArguments = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends QueryManyBase<TArguments, void, TEntityConstructor, TError> {
+    static readonly queryPrefix = "__query__fragment__many__";
+    constructor(options: UseQueryManyOptions<TArguments, void, TEntityConstructor, TError>);
+    useQuery(args: TArguments): InstanceType<TEntityConstructor>[];
+}

package/dist/queries/QueryFragmentOne.d.ts

@@ -0,0 +1,9 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { UseQueryOneOptions } from './types';
+import { QueryOneBase } from './QueryOneBase';
+export declare class QueryFragmentOne<TArguments = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends QueryOneBase<TArguments, void, TEntityConstructor, TError> {
+    static readonly queryPrefix = "__query__fragment__one__";
+    constructor(options: UseQueryOneOptions<TArguments, void, TEntityConstructor, TError>);
+    useQuery(args: TArguments): InstanceType<TEntityConstructor> | null;
+}

package/dist/queries/QueryMany.d.ts

@@ -0,0 +1,11 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { UseQueryManyOptions } from './types';
+import { QueryManyBase } from './QueryManyBase';
+export declare class QueryMany<TArguments = void, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends QueryManyBase<TArguments, TMeta, TEntityConstructor, TError> {
+    static readonly queryPrefix = "__query__many__";
+    constructor(options: UseQueryManyOptions<TArguments, TMeta, TEntityConstructor, TError>);
+    useSuspenseQuery(args: TArguments): InstanceType<TEntityConstructor>[];
+    useDeferredQuery(args: TArguments): InstanceType<TEntityConstructor>[];
+    useQuery(args: TArguments, meta: TMeta): InstanceType<TEntityConstructor>[];
+}

package/dist/queries/QueryManyBase.d.ts

@@ -0,0 +1,34 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny, EntityCollection, EntityId } from '../entity';
+import { InferEntityData } from '../utils';
+import { QueryBase } from './QueryBase';
+import { UseQueryManyOptions } from './types';
+export declare abstract class QueryManyBase<TArguments, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends QueryBase<TArguments> {
+    protected readonly options: UseQueryManyOptions<TArguments, TMeta, TEntityConstructor, TError>;
+    protected readonly collection: EntityCollection<TEntityConstructor>;
+    constructor(queryPrefix: string, options: UseQueryManyOptions<TArguments, TMeta, TEntityConstructor, TError>);
+    prefetch(args: TArguments): Promise<void>;
+    ensureData(args: TArguments): Promise<EntityId[]>;
+    invalidate(args: TArguments): void;
+    setQueryData(data: InferEntityData<TEntityConstructor>[], args: TArguments): void;
+    /**
+     * Returns the current entity ID array stored in the TanStack query cache
+     * for the given arguments.
+     */
+    getQueryIds(args: TArguments): EntityId[];
+    /**
+     * Directly sets the entity ID array in the TanStack query cache
+     * for the given arguments. Used by relation mutations for optimistic updates.
+     */
+    setQueryIds(ids: EntityId[], args: TArguments): void;
+    /**
+     * Public accessor for the query key. Used by relation mutations
+     * to construct invalidation targets.
+     */
+    getQueryKey(args: TArguments): unknown[];
+    protected getEntities(ids: EntityId[]): InstanceType<TEntityConstructor>[];
+    protected queryFnWrapper(args: TArguments): {
+        run: () => Promise<EntityId[]>;
+        queryKey: unknown[];
+    };
+}

package/dist/queries/QueryOne.d.ts

@@ -0,0 +1,11 @@
+import { DefaultError } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { UseQueryOneOptions } from './types';
+import { QueryOneBase } from './QueryOneBase';
+export declare class QueryOne<TArguments = void, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends QueryOneBase<TArguments, TMeta, TEntityConstructor, TError> {
+    static readonly queryPrefix = "__query__one__";
+    constructor(options: UseQueryOneOptions<TArguments, TMeta, TEntityConstructor, TError>);
+    useSuspenseQuery(args: TArguments): InstanceType<TEntityConstructor> | null;
+    useDeferredQuery(args: TArguments): InstanceType<TEntityConstructor> | null;
+    useQuery(args: TArguments, meta: TMeta): InstanceType<TEntityConstructor> | null;
+}

package/dist/queries/QueryOneBase.d.ts

@@ -0,0 +1,19 @@
+import { EntityConstructorAny, EntityCollection, EntityId } from '../entity';
+import { QueryBase } from './QueryBase';
+import { UseQueryOneOptions } from './types';
+import { InferEntityData } from '../utils';
+import { DefaultError } from '@tanstack/react-query';
+export declare class QueryOneBase<TArguments, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends QueryBase<TArguments> {
+    protected readonly options: UseQueryOneOptions<TArguments, TMeta, TEntityConstructor, TError>;
+    protected readonly collection: EntityCollection<TEntityConstructor>;
+    constructor(queryPrefix: string, options: UseQueryOneOptions<TArguments, TMeta, TEntityConstructor, TError>);
+    prefetch(args: TArguments): Promise<void>;
+    ensureData(args: TArguments): Promise<EntityId>;
+    invalidate(args: TArguments): void;
+    setQueryData(data: InferEntityData<TEntityConstructor>, args: TArguments): void;
+    protected getEntity(id: EntityId): InstanceType<TEntityConstructor> | null;
+    protected queryFnWrapper(args: TArguments): {
+        run: () => Promise<EntityId>;
+        queryKey: unknown[];
+    };
+}

package/dist/queries/index.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryManyFunction, UseQueryOneOptions, UseQueryCommonOptions, UseQueryManyOptions, UseQueryOneFunction } from './types';
+import { QueryBase } from './QueryBase';
+import { QueryFragmentMany } from './QueryFragmentMany';
+import { QueryFragmentOne } from './QueryFragmentOne';
+import { QueryMany } from './QueryMany';
+import { QueryManyBase } from './QueryManyBase';
+import { QueryOne } from './QueryOne';
+import { QueryOneBase } from './QueryOneBase';
+export { QueryBase, QueryFragmentMany, QueryFragmentOne, QueryMany, QueryManyBase, QueryOne, QueryOneBase, };
+export type { UseQueryCommonOptions, UseQueryManyFunction, UseQueryManyOptions, UseQueryOneFunction, UseQueryOneOptions, };

package/dist/queries/types.d.ts

@@ -0,0 +1,23 @@
+import { DefaultError, NetworkMode } from '@tanstack/react-query';
+import { EntityConstructorAny } from '../entity';
+import { MQClientContextRegistered } from '../client/types';
+import { InferEntityData } from '../utils';
+export type UseQueryManyFunction<TArguments, TEntityConstructor extends EntityConstructorAny> = (args: TArguments, context: MQClientContextRegistered) => InferEntityData<TEntityConstructor>[] | Promise<InferEntityData<TEntityConstructor>[]>;
+export type UseQueryOneFunction<TArguments, TEntityConstructor extends EntityConstructorAny> = (args: TArguments, context: MQClientContextRegistered) => InferEntityData<TEntityConstructor> | Promise<InferEntityData<TEntityConstructor>>;
+export interface UseQueryCommonOptions<TArguments, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> {
+    entity: TEntityConstructor;
+    queryKey: () => ReadonlyArray<unknown>;
+    staleTime?: number | "static";
+    gcTime?: number;
+    enabled?: boolean | ((meta: TMeta, args: TArguments) => boolean);
+    networkMode?: NetworkMode;
+    retry?: boolean | number | ((failureCount: number, error: TError) => boolean);
+    retryOnMount?: boolean;
+    retryDelay?: number | ((failureCount: number, error: TError) => number);
+}
+export interface UseQueryOneOptions<TArguments, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends UseQueryCommonOptions<TArguments, TMeta, TEntityConstructor, TError> {
+    queryFn?: UseQueryOneFunction<TArguments, TEntityConstructor>;
+}
+export interface UseQueryManyOptions<TArguments, TMeta = void, TEntityConstructor extends EntityConstructorAny = EntityConstructorAny, TError extends DefaultError = DefaultError> extends UseQueryCommonOptions<TArguments, TMeta, TEntityConstructor, TError> {
+    queryFn?: UseQueryManyFunction<TArguments, TEntityConstructor>;
+}

package/dist/react/createReactContext.d.ts

@@ -0,0 +1,8 @@
+import { MQClient } from '../client';
+export declare function createReactContext<TMQClient extends MQClient<any>>(): {
+    Provider: ({ children, client, }: {
+        children: React.ReactNode;
+        client: TMQClient;
+    }) => import("react/jsx-runtime").JSX.Element;
+    useContext: () => TMQClient;
+};

package/dist/react/index.d.ts

@@ -0,0 +1,2 @@
+import { createReactContext } from './createReactContext';
+export { createReactContext };

package/dist/utils/generateEntityId.d.ts

@@ -0,0 +1,2 @@
+import { EntityConstructorAny } from '../entity';
+export declare function generateEntityId(entityConstructor: EntityConstructorAny): string;

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+import { generateEntityId } from './generateEntityId';
+import { invalidateQueryByHash } from './invalidateQueryByHash';
+import { InferEntity, InferEntityData } from './types';
+export { invalidateQueryByHash, generateEntityId };
+export type { InferEntity, InferEntityData };

package/dist/utils/invalidateQueryByHash.d.ts

@@ -0,0 +1,2 @@
+import { QueryCache } from '@tanstack/react-query';
+export declare function invalidateQueryByHash(hash: string, cache: QueryCache, onQueryNotFound?: (hash: string) => void): void;

package/dist/utils/types.d.ts

@@ -0,0 +1,7 @@
+import { EntityAny, EntityDataAny } from '../entity';
+export type InferEntity<T> = T extends {
+    new (...args: any[]): infer E;
+} ? E extends EntityAny ? E : never : T extends EntityAny ? T : never;
+export type InferEntityData<T> = InferEntity<T> extends {
+    hydrate(data: infer TData): void;
+} ? TData : T extends EntityDataAny ? T : never;

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@mobx-query/core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "author": "smashboy",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "main": "./dist/core.js",
   "scripts": {
     "dev": "vite",
     "build": "tsc -b && vite build",

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/eslint.config.js

@@ -1,29 +0,0 @@
-import js from "@eslint/js";
-import globals from "globals";
-import reactHooks from "eslint-plugin-react-hooks";
-import reactRefresh from "eslint-plugin-react-refresh";
-import tseslint from "typescript-eslint";
-import { globalIgnores } from "eslint/config";
-
-export default tseslint.config([
-  globalIgnores(["dist"]),
-  {
-    files: ["**/*.{ts,tsx}"],
-    extends: [
-      js.configs.recommended,
-      tseslint.configs.recommended,
-      reactHooks.configs["recommended-latest"],
-      reactRefresh.configs.vite,
-    ],
-    languageOptions: {
-      ecmaVersion: 2020,
-      globals: globals.browser,
-    },
-    rules: {
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-unsafe-function-type": "off",
-      "react-hooks/rules-of-hooks": "off",
-      "@typescript-eslint/no-empty-object-type": "off",
-    },
-  },
-]);

package/index.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Vite + React + TS</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

package/src/App.tsx

@@ -1,5 +0,0 @@
-const App = () => {
-  return <div />;
-};
-
-export default App;

package/src/api/constants.ts

@@ -1 +0,0 @@
-export const API_URL = "https://jsonplaceholder.typicode.com";