@mobx-query/core 0.2.2 → 0.2.4

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

@@ -1,94 +0,0 @@
-import {
-  type DefaultError,
-  type MutationFunctionContext,
-  useMutation,
-} from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import type { UseEntityMutationHookOptions } from "./types";
-import { EntityMutationBase } from "./EntityMutationBase";
-import { action } from "mobx";
-
-export 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
-    >,
-  ) {
-    super(DeleteMutation.mutationPrefix, options);
-  }
-
-  useMutation() {
-    const mutation = useMutation({
-      mutationFn: () => this.options.mutationFn(void 0, this.context),
-      onMutate: (_, context) => this.onMutate(context),
-      onSuccess: (_, __, result, context) => this.onSuccess(result, context),
-      onError: (error, _, result, context) =>
-        this.onError(error, result, context),
-      onSettled: (_, error, __, result, context) =>
-        this.onSettled(error, result, context),
-      gcTime: this.options.gcTime,
-      meta: this.options.meta,
-      networkMode: this.options.networkMode,
-      retry: this.options.retry,
-      retryDelay: this.options.retryDelay,
-      scope: this.options.scope,
-      throwOnError: this.options.throwOnError,
-      mutationKey: this.entityMutationKey,
-    });
-
-    return () => mutation.mutate();
-  }
-
-  @action private async onMutate(
-    context: MutationFunctionContext,
-  ): Promise<TMutateResult | undefined> {
-    const result = await this.onMutateBase(context);
-    this.collection.deletedRecordIds.add(this.options.instance.id);
-    return result;
-  }
-
-  @action private async onSuccess(
-    result: TMutateResult | undefined,
-    ctx: MutationFunctionContext,
-  ) {
-    await this.onSuccessBase(result, ctx);
-    this.collection.deletedRecordIds.delete(this.options.instance.id);
-    this.collection.deleteEntity(this.options.instance.id);
-  }
-
-  @action private async onError(
-    error: TError,
-    result: TMutateResult | undefined,
-    ctx: MutationFunctionContext,
-  ) {
-    await this.onErrorBase(error, result, ctx);
-    this.collection.deletedRecordIds.delete(this.options.instance.id);
-  }
-
-  private async onSettled(
-    error: TError | null,
-    result: TMutateResult | undefined,
-    ctx: MutationFunctionContext,
-  ) {
-    await this.onSettledBase(error, result, ctx);
-  }
-
-  mutate(input: void): void {
-    this.mutateBase(input, {
-      onMutate: (_, context) => this.onMutate(context),
-      onSuccess: (_, result, context) => this.onSuccess(result, context),
-      onError: (error, _, result, context) =>
-        this.onError(error, result, context),
-      onSettled: (_, error, result, context) =>
-        this.onSettled(error, result, context),
-    });
-  }
-}

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

@@ -1,110 +0,0 @@
-import type { EntityConstructorAny, EntityAny } from "../entity";
-import { OptimisticMutationStrategy } from "./OptimisticMutationStrategy";
-import type {
-  EntityMutationCallbacks,
-  UseEntityMutationHookOptions,
-} from "./types";
-import type {
-  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 abstract class EntityMutationBase<
-  TInput,
-  TEntityConstructor extends EntityConstructorAny,
-  TError = DefaultError,
-  TMutateResult = unknown,
-> extends MutationBase<TEntityConstructor> {
-  protected readonly mutationStrategy: OptimisticMutationStrategy;
-
-  constructor(
-    mutationPrefix: string,
-    protected readonly options: UseEntityMutationHookOptions<
-      TEntityConstructor,
-      TError,
-      TMutateResult
-    >,
-  ) {
-    super(mutationPrefix, options.entity);
-    this.mutationStrategy = this.createMutationStrategy([options.instance], {
-      invalidationStrategy: options.invalidationStrategy,
-      errorStrategy: options.errorStrategy,
-      invalidateOnError: options.invalidateOnError,
-    });
-  }
-
-  get entityMutationKey() {
-    return [...this.baseMutationKey, this.options.instance.id];
-  }
-
-  protected async onMutateBase(
-    context: MutationFunctionContext,
-  ): Promise<TMutateResult | undefined> {
-    this.mutationStrategy.onMutate();
-    const result = await this.options.onMutate?.(
-      this.options.instance,
-      context,
-    );
-    return result;
-  }
-
-  protected async onSuccessBase(
-    result: TMutateResult | undefined,
-    ctx: MutationFunctionContext,
-  ) {
-    this.mutationStrategy.onSuccess();
-    await this.options.onSuccess?.(this.options.instance, result, ctx);
-  }
-
-  protected async onErrorBase(
-    error: TError,
-    result: TMutateResult | undefined,
-    ctx: MutationFunctionContext,
-  ) {
-    this.mutationStrategy.onError();
-    await this.options.onError?.(error, this.options.instance, result, ctx);
-  }
-
-  protected async onSettledBase(
-    error: TError | null,
-    result: TMutateResult | undefined,
-    ctx: MutationFunctionContext,
-  ) {
-    await this.options.onSettled?.(this.options.instance, error, result, ctx);
-  }
-
-  protected mutateBase(
-    input: TInput,
-    callbacks: EntityMutationCallbacks<EntityAny, TError, TMutateResult>,
-  ) {
-    this.runSyncMutation(
-      input,
-      (_, context) => this.options.mutationFn(void 0, context),
-      {
-        onMutate: async (_, context) =>
-          callbacks.onMutate?.(this.options.instance, context),
-        onSuccess: (_, __, result, context) =>
-          callbacks.onSuccess?.(this.options.instance, result!, context),
-        onError: (error, _, result, context) =>
-          callbacks.onError?.(error, this.options.instance, result, context),
-        onSettled: (_, error, __, result, context) =>
-          callbacks.onSettled?.(this.options.instance, error, result, context),
-        gcTime: this.options.gcTime,
-        meta: this.options.meta,
-        networkMode: this.options.networkMode,
-        retry: this.options.retry,
-        retryDelay: this.options.retryDelay,
-        scope: this.options.scope,
-        mutationKey: this.entityMutationKey,
-      },
-    );
-  }
-
-  abstract mutate(input: TInput): void;
-}

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

@@ -1,40 +0,0 @@
-import type { EntityAny, EntityConstructorAny } from "../entity";
-import { EntityCollection } from "../entity/EntityCollection";
-import { MQClientAccessor } from "../client";
-import { OptimisticMutationStrategy } from "./OptimisticMutationStrategy";
-import type { OptimisticMutationStrategyOptions } from "./types";
-
-export class MutationBase<
-  TEntityConstructor extends EntityConstructorAny,
-> extends MQClientAccessor {
-  protected readonly collection: EntityCollection<TEntityConstructor>;
-
-  constructor(
-    protected readonly mutationPrefix: string,
-    protected readonly entity: TEntityConstructor,
-  ) {
-    super();
-
-    this.collection = this.getEntityCollection(entity);
-  }
-
-  get baseMutationKey() {
-    return [this.entity.name, this.mutationPrefix];
-  }
-
-  protected createMutationStrategy(
-    entities: EntityAny[],
-    options: OptimisticMutationStrategyOptions,
-  ) {
-    const mutationStrategy = new OptimisticMutationStrategy(
-      this.entity,
-      entities,
-      {
-        invalidationStrategy: options.invalidationStrategy,
-        errorStrategy: options.errorStrategy,
-        invalidateOnError: options.invalidateOnError,
-      },
-    );
-    return mutationStrategy;
-  }
-}

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

@@ -1,122 +0,0 @@
-import { __MOBX_QUERY__ } from "../client/MQClient";
-import {
-  type EntityConstructorAny,
-  type EntityAny,
-  EntityState,
-} from "../entity";
-import type { OptimisticMutationStrategyOptions } from "./types";
-import { action } from "mobx";
-import { invalidateQueryByHash } from "../utils";
-import { MQClientAccessor } from "../client";
-import {
-  OptimisticMutationErrorStrategy,
-  OptimisticMutationInvalidationStrategy,
-} from "./constants";
-
-export class OptimisticMutationStrategy extends MQClientAccessor {
-  constructor(
-    private readonly entityConstructor: EntityConstructorAny,
-    private readonly entities: EntityAny[],
-    private readonly options?: OptimisticMutationStrategyOptions,
-  ) {
-    super();
-  }
-
-  get invalidationStrategy() {
-    return (
-      this.options?.invalidationStrategy ??
-      __MOBX_QUERY__.options.invalidationStrategy
-    );
-  }
-
-  get mutationErrorStrategy() {
-    return this.options?.errorStrategy ?? __MOBX_QUERY__.options.errorStrategy;
-  }
-
-  get invalidateOnError() {
-    return (
-      this.options?.invalidateOnError ??
-      __MOBX_QUERY__.options.invalidateOnError
-    );
-  }
-
-  @action onMutate() {
-    this.queryClient.cancelQueries({ queryKey: [this.entityConstructor.name] });
-    for (const entity of this.entities) {
-      entity.state = EntityState.PENDING;
-    }
-  }
-
-  @action onSuccess() {
-    for (const entity of this.entities) {
-      entity.state = EntityState.CONFIRMED;
-    }
-    this.runInvalidationStrategy();
-  }
-
-  @action onError(ignoreReset: boolean = false) {
-    for (const entity of this.entities) {
-      entity.state = EntityState.FAILED;
-
-      if (
-        this.mutationErrorStrategy ===
-          OptimisticMutationErrorStrategy.ROLLBACK &&
-        !ignoreReset
-      ) {
-        entity.reset();
-      }
-    }
-
-    if (this.invalidateOnError) {
-      this.runInvalidationStrategy();
-    }
-  }
-
-  private runInvalidationStrategy() {
-    const strategy = this.invalidationStrategy;
-
-    switch (strategy) {
-      case OptimisticMutationInvalidationStrategy.ALL_QUERIES:
-        this.queryClient.invalidateQueries();
-        break;
-      case OptimisticMutationInvalidationStrategy.ALL_ENTITY_QUERIES:
-        this.invalidateCollectionRelatedQueries();
-        break;
-      case OptimisticMutationInvalidationStrategy.REFERENCED_QUERIES:
-        this.invalidateEntityRelatedQueries();
-        break;
-      default:
-        break;
-    }
-  }
-
-  private async invalidateCollectionRelatedQueries() {
-    await this.queryClient
-      .invalidateQueries({ queryKey: [this.entityConstructor.name] })
-      .catch((err) => console.error(err));
-  }
-
-  private invalidateEntityRelatedQueries() {
-    const cache = this.queryClient.getQueryCache();
-
-    const entitiesByHash: Record<string, EntityAny[]> = {};
-
-    for (const entity of this.entities) {
-      for (const hash of entity.queryHashes) {
-        if (!entitiesByHash[hash]) {
-          entitiesByHash[hash] = [];
-        }
-
-        entitiesByHash[hash].push(entity);
-      }
-    }
-
-    for (const [hash, entities] of Object.entries(entitiesByHash)) {
-      invalidateQueryByHash(hash, cache, () => {
-        for (const entity of entities) {
-          entity._removeQueryHashes([hash]);
-        }
-      });
-    }
-  }
-}

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

@@ -1,76 +0,0 @@
-import { type DefaultError, useMutation } from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import type { UseEntityMutationHookOptions } from "./types";
-import { EntityMutationBase } from "./EntityMutationBase";
-
-export 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
-    >,
-  ) {
-    super(UpdateMutation.mutationPrefix, options);
-  }
-
-  useMutation() {
-    const mutation = useMutation({
-      mutationFn: () => this.options.mutationFn(void 0, this.context),
-      onMutate: async (_, context) => this.onMutateBase(context),
-      onSuccess: (_, __, result, context) =>
-        this.onSuccessBase(result, context),
-      onError: (error, _, result, context) =>
-        this.onErrorBase(error, result, context),
-      onSettled: (_, error, __, result, context) =>
-        this.onSettledBase(error, result, context),
-      gcTime: this.options.gcTime,
-      meta: this.options.meta,
-      networkMode: this.options.networkMode,
-      retry: this.options.retry,
-      retryDelay: this.options.retryDelay,
-      scope: this.options.scope,
-      throwOnError: this.options.throwOnError,
-      mutationKey: this.entityMutationKey,
-    });
-
-    return () => {
-      if (!this.options.instance.isDirty) {
-        return console.warn(
-          "Entity values has not been changed, mutation is skipped.",
-        );
-      }
-
-      // if (this.entity.state === EntityState.PENDING) {
-      //   return console.warn(
-      //     'Entity update mutation is already in progress, new mutation is skipped.',
-      //   )
-      // }
-
-      mutation.mutate();
-    };
-  }
-
-  mutate(input: void): void {
-    if (!this.options.instance.isDirty) {
-      return console.warn(
-        "Entity values has not been changed, mutation is skipped.",
-      );
-    }
-
-    this.mutateBase(input, {
-      onMutate: (_, context) => this.onMutateBase(context),
-      onSuccess: (_, result, context) => this.onSuccessBase(result, context),
-      onError: (error, _, result, context) =>
-        this.onErrorBase(error, result, context),
-      onSettled: (_, error, result, context) =>
-        this.onSettledBase(error, result, context),
-    });
-  }
-}

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

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

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

@@ -1,44 +0,0 @@
-import type {
-  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,
-};