@mobx-query/core 0.2.2 → 0.2.3

package/src/libs/mobx-query/mutations/types.ts

@@ -1,205 +0,0 @@
-import type {
-  DefaultError,
-  MutationFunctionContext,
-  UseMutationOptions,
-} from "@tanstack/react-query";
-import type { MQClientContextRegistered } from "../client/types";
-import type { EntityAny, EntityConstructorAny } from "../entity";
-import { OptimisticMutationStrategy } from "./OptimisticMutationStrategy";
-import type {
-  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"
-> {
-  // mutationKey?: () => ReadonlyArray<unknown>
-}
-
-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/src/libs/mobx-query/queries/QueryBase.ts

@@ -1,65 +0,0 @@
-import { hashKey, useIsFetching } from "@tanstack/react-query";
-import { MQClientAccessor } from "../client";
-import type { EntityConstructorAny, EntityDataAny } from "../entity";
-
-export abstract class QueryBase<TArguments = unknown> extends MQClientAccessor {
-  constructor(
-    private readonly entityConstructors: EntityConstructorAny[],
-    private readonly baseQueryKeysRest: () => unknown[],
-  ) {
-    super();
-  }
-
-  get baseQueryKey() {
-    return [
-      this.entityConstructors.map((e) => e.name).join("_"),
-      ...this.baseQueryKeysRest(),
-    ];
-  }
-
-  get baseQueryHash() {
-    return hashKey(this.baseQueryKey);
-  }
-
-  protected createQueryKey(args: TArguments) {
-    return [...this.baseQueryKey, args];
-  }
-
-  protected createQueryHash(args: TArguments) {
-    return hashKey(this.createQueryKey(args));
-  }
-
-  useIsFetching(args: TArguments) {
-    return useIsFetching({
-      queryKey: this.createQueryKey(args),
-    });
-  }
-
-  protected setOneEntity(
-    data: EntityDataAny,
-    queryKey: unknown[],
-    entityConstructor: EntityConstructorAny,
-  ) {
-    const collection = this.getEntityCollection(entityConstructor);
-    const entity = collection.setEntity(data, [hashKey(queryKey)]);
-
-    return entity;
-  }
-
-  protected setManyEntities(
-    data: EntityDataAny[],
-    queryKey: unknown[],
-    entityConstructor: EntityConstructorAny,
-  ) {
-    if (typeof data !== "object" || !Array.isArray(data)) {
-      throw new Error(
-        `Query function for ${entityConstructor.name} must return an array of entities`,
-      );
-    }
-
-    const collection = this.getEntityCollection(entityConstructor);
-    const entities = collection.setEntities(data, [hashKey(queryKey)]);
-
-    return entities;
-  }
-}

package/src/libs/mobx-query/queries/QueryFragmentMany.ts

@@ -1,31 +0,0 @@
-import { type DefaultError, useQuery } from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import type { UseQueryManyOptions } from "./types";
-import { QueryManyBase } from "./QueryManyBase";
-
-export 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>,
-  ) {
-    super(QueryFragmentMany.queryPrefix, options);
-  }
-
-  useQuery(args: TArguments) {
-    const queryFn = this.queryFnWrapper(args);
-
-    const res = useQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      staleTime: Infinity,
-      gcTime: Infinity,
-    });
-
-    return this.getEntities(res.data ?? []);
-  }
-}

package/src/libs/mobx-query/queries/QueryFragmentOne.ts

@@ -1,35 +0,0 @@
-import { type DefaultError, useQuery } from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import type { UseQueryOneOptions } from "./types";
-import { QueryOneBase } from "./QueryOneBase";
-
-export 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>,
-  ) {
-    super(QueryFragmentOne.queryPrefix, options);
-  }
-
-  useQuery(args: TArguments) {
-    const queryFn = this.queryFnWrapper(args);
-
-    const res = useQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      staleTime: Infinity,
-      gcTime: Infinity,
-    });
-
-    if (!res.data) {
-      return null;
-    }
-
-    return this.getEntity(res.data);
-  }
-}

package/src/libs/mobx-query/queries/QueryMany.ts

@@ -1,80 +0,0 @@
-import {
-  type DefaultError,
-  useQuery,
-  useSuspenseQuery,
-} from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import type { UseQueryManyOptions } from "./types";
-import { QueryManyBase } from "./QueryManyBase";
-import { useDeferredValue } from "react";
-
-export 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>,
-  ) {
-    super(QueryMany.queryPrefix, options);
-  }
-
-  useSuspenseQuery(args: TArguments) {
-    const queryFn = this.queryFnWrapper(args);
-
-    const res = useSuspenseQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      ...(this.options.staleTime !== undefined
-        ? { staleTime: this.options.staleTime }
-        : {}),
-      ...(this.options.gcTime !== undefined
-        ? { gcTime: this.options.gcTime }
-        : {}),
-    });
-
-    return this.getEntities(res.data);
-  }
-
-  useDeferredQuery(args: TArguments) {
-    const deferredArgs = useDeferredValue(args);
-    const queryFn = this.queryFnWrapper(deferredArgs);
-
-    const res = useSuspenseQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      ...(this.options.staleTime !== undefined
-        ? { staleTime: this.options.staleTime }
-        : {}),
-      ...(this.options.gcTime !== undefined
-        ? { gcTime: this.options.gcTime }
-        : {}),
-    });
-
-    return this.getEntities(res.data);
-  }
-
-  useQuery(args: TArguments, meta: TMeta) {
-    const queryFn = this.queryFnWrapper(args);
-
-    const res = useQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      enabled:
-        typeof this.options.enabled === "function"
-          ? this.options.enabled(meta, args)
-          : this.options.enabled,
-      ...(this.options.staleTime !== undefined
-        ? { staleTime: this.options.staleTime }
-        : {}),
-      ...(this.options.gcTime !== undefined
-        ? { gcTime: this.options.gcTime }
-        : {}),
-    });
-
-    return this.getEntities(res.data ?? []);
-  }
-}

package/src/libs/mobx-query/queries/QueryManyBase.ts

@@ -1,135 +0,0 @@
-import type { DefaultError } from "@tanstack/react-query";
-import type {
-  EntityAny,
-  EntityConstructorAny,
-  EntityCollection,
-  EntityId,
-  EntityDataAny,
-} from "../entity";
-import { type InferEntityData, invalidateQueryByHash } from "../utils";
-import { QueryBase } from "./QueryBase";
-import type { UseQueryManyOptions } from "./types";
-
-export abstract class QueryManyBase<
-  TArguments,
-  TMeta = void,
-  TEntityConstructor extends EntityConstructorAny = EntityConstructorAny,
-  TError extends DefaultError = DefaultError,
-> extends QueryBase<TArguments> {
-  protected readonly collection: EntityCollection<TEntityConstructor>;
-
-  constructor(
-    queryPrefix: string,
-    protected readonly options: UseQueryManyOptions<
-      TArguments,
-      TMeta,
-      TEntityConstructor,
-      TError
-    >,
-  ) {
-    super([options.entity], () => [queryPrefix, ...options.queryKey()]);
-    this.collection = this.getEntityCollection(options.entity);
-  }
-
-  prefetch(args: TArguments) {
-    const queryFn = this.queryFnWrapper(args);
-    return this.queryClient.prefetchQuery({
-      queryKey: this.createQueryKey(args),
-      queryFn: () => queryFn.run(),
-    });
-  }
-
-  ensureData(args: TArguments) {
-    const queryFn = this.queryFnWrapper(args);
-    return this.queryClient.ensureQueryData({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-    });
-  }
-
-  invalidate(args: TArguments) {
-    invalidateQueryByHash(
-      this.createQueryHash(args),
-      this.queryClient.getQueryCache(),
-    );
-  }
-
-  setQueryData(data: InferEntityData<TEntityConstructor>[], args: TArguments) {
-    const queryKey = this.createQueryKey(args);
-    const [_, ids] = this.setManyEntities(
-      data as EntityDataAny[],
-      queryKey,
-      this.options.entity,
-    );
-    this.queryClient.setQueryData(queryKey, ids);
-  }
-
-  /**
-   * Returns the current entity ID array stored in the TanStack query cache
-   * for the given arguments.
-   */
-  getQueryIds(args: TArguments): EntityId[] {
-    return (
-      this.queryClient.getQueryData<EntityId[]>(this.createQueryKey(args)) ?? []
-    );
-  }
-
-  /**
-   * 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) {
-    this.queryClient.setQueryData(this.createQueryKey(args), ids);
-  }
-
-  /**
-   * Public accessor for the query key. Used by relation mutations
-   * to construct invalidation targets.
-   */
-  getQueryKey(args: TArguments) {
-    return this.createQueryKey(args);
-  }
-
-  protected getEntities(ids: EntityId[]) {
-    const list: EntityAny[] = [];
-
-    for (const id of ids) {
-      if (this.collection.deletedRecordIds.has(id)) {
-        continue;
-      }
-
-      const entity = this.collection.collection.get(id);
-
-      if (entity) {
-        list.push(entity);
-      }
-    }
-
-    return list as unknown as InstanceType<TEntityConstructor>[];
-  }
-
-  protected queryFnWrapper(args: TArguments) {
-    const queryKey = this.createQueryKey(args);
-    return {
-      run: async () => {
-        if (!this.options.queryFn) {
-          throw new Error("Query function is not defined");
-        }
-
-        const data = (await this.options.queryFn(
-          args,
-          this.context,
-        )) as EntityDataAny[];
-
-        const [_, ids] = this.setManyEntities(
-          data,
-          queryKey,
-          this.options.entity,
-        );
-
-        return ids;
-      },
-      queryKey,
-    };
-  }
-}

package/src/libs/mobx-query/queries/QueryOne.ts

@@ -1,84 +0,0 @@
-import {
-  type DefaultError,
-  useQuery,
-  useSuspenseQuery,
-} from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import type { UseQueryOneOptions } from "./types";
-import { QueryOneBase } from "./QueryOneBase";
-import { useDeferredValue } from "react";
-
-export 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>,
-  ) {
-    super(QueryOne.queryPrefix, options);
-  }
-
-  useSuspenseQuery(args: TArguments) {
-    const queryFn = this.queryFnWrapper(args);
-
-    const res = useSuspenseQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      ...(this.options.staleTime !== undefined
-        ? { staleTime: this.options.staleTime }
-        : {}),
-      ...(this.options.gcTime !== undefined
-        ? { gcTime: this.options.gcTime }
-        : {}),
-    });
-
-    return this.getEntity(res.data);
-  }
-
-  useDeferredQuery(args: TArguments) {
-    const deferredArgs = useDeferredValue(args);
-    const queryFn = this.queryFnWrapper(deferredArgs);
-
-    const res = useSuspenseQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      ...(this.options.staleTime !== undefined
-        ? { staleTime: this.options.staleTime }
-        : {}),
-      ...(this.options.gcTime !== undefined
-        ? { gcTime: this.options.gcTime }
-        : {}),
-    });
-
-    return this.getEntity(res.data);
-  }
-
-  useQuery(args: TArguments, meta: TMeta) {
-    const queryFn = this.queryFnWrapper(args);
-
-    const res = useQuery({
-      queryKey: queryFn.queryKey,
-      queryFn: () => queryFn.run(),
-      enabled:
-        typeof this.options.enabled === "function"
-          ? this.options.enabled(meta, args)
-          : this.options.enabled,
-      ...(this.options.staleTime !== undefined
-        ? { staleTime: this.options.staleTime }
-        : {}),
-      ...(this.options.gcTime !== undefined
-        ? { gcTime: this.options.gcTime }
-        : {}),
-    });
-
-    if (!res.data) {
-      return null;
-    }
-
-    return this.getEntity(res.data);
-  }
-}