@mobx-query/core 0.2.2 → 0.2.4

package/src/libs/mobx-query/entity/EntityCollection.ts

@@ -1,285 +0,0 @@
-import { action, computed, observable } from "mobx";
-import type { EntityConstructor, EntityConstructorAny } from "./Entity";
-import { QueryClient } from "@tanstack/react-query";
-import type { EntityDataAny, EntityId } from "./types";
-
-export class EntityCollection<
-  TEntityConstructor extends EntityConstructorAny = EntityConstructorAny,
-> {
-  @observable accessor collection = new Map<
-    EntityId,
-    InstanceType<TEntityConstructor>
-  >();
-  @observable accessor deletedRecordIds = new Set<EntityId>();
-  @observable accessor clientOnlyEntityIds = new Set<EntityId>();
-
-  constructor(
-    private readonly entityConstructor: EntityConstructor<
-      any,
-      any,
-      InstanceType<TEntityConstructor>
-    >,
-    private readonly queryClient: QueryClient,
-  ) {
-    this.initQueryClientCacheListener();
-  }
-
-  @computed get size() {
-    return this.collection.size;
-  }
-
-  @computed get entities() {
-    const entities: InstanceType<TEntityConstructor>[] = [];
-
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      entities.push(entity);
-    }
-
-    return entities;
-  }
-
-  @computed get clientOnlyEntitiesMap() {
-    const entities = new Map<EntityId, InstanceType<TEntityConstructor>>();
-
-    for (const entityId of this.clientOnlyEntityIds.values()) {
-      const entity = this.collection.get(entityId);
-
-      if (!entity) {
-        continue;
-      }
-
-      entities.set(entityId, entity);
-    }
-
-    return entities;
-  }
-
-  @computed get clientOnlyEntities() {
-    const entities: InstanceType<TEntityConstructor>[] = [];
-
-    for (const entityId of this.clientOnlyEntityIds.values()) {
-      const entity = this.collection.get(entityId);
-
-      if (!entity) {
-        continue;
-      }
-
-      entities.push(entity);
-    }
-
-    return entities;
-  }
-
-  @action setEntity(data: EntityDataAny, queryHashes?: string[]) {
-    // if (clearQueryHashes && queryHashes) {
-    //   console.log('clearQueryHashes', queryHashes)
-    //   this.removeQueryHashesFromAllEntities(queryHashes)
-    // }
-
-    const entity =
-      new this.entityConstructor() as InstanceType<TEntityConstructor>;
-    entity.hydrate(data);
-    entity._markAsHydrated();
-
-    const prevEntity = this.collection.get(entity.id) as
-      | InstanceType<TEntityConstructor>
-      | undefined;
-
-    const updatedQueryHashes = prevEntity
-      ? [...prevEntity.queryHashes, ...(queryHashes || [])]
-      : [...(queryHashes || [])];
-
-    if (prevEntity) {
-      if (queryHashes) {
-        for (const hash of queryHashes) {
-          prevEntity.queryHashes.add(hash);
-        }
-      }
-
-      prevEntity.hydrate(data);
-      prevEntity._clearDirty();
-
-      return prevEntity;
-    }
-
-    entity._init(updatedQueryHashes, {
-      onAllQueryHashesRemoved: (entityId: EntityId) =>
-        this.deleteEntity(entityId),
-    });
-
-    this.collection.set(entity.id, entity);
-    return entity;
-  }
-
-  @action setEntities(entityData: EntityDataAny[], queryHashes: string[]) {
-    const entities: InstanceType<TEntityConstructor>[] = [];
-    const ids: EntityId[] = [];
-
-    if (!Array.isArray(entityData)) {
-      throw new Error("setEntities: entityData must be an array");
-    }
-
-    if (queryHashes) {
-      this.removeQueryHashesFromAllEntities(queryHashes);
-    }
-
-    for (const record of entityData) {
-      const entity = this.setEntity(record, queryHashes);
-      entities.push(entity);
-      ids.push(entity.id);
-    }
-
-    return [entities, ids] as const;
-  }
-
-  @action deleteEntity(entityId: EntityId) {
-    this.collection.delete(entityId);
-    this.clientOnlyEntityIds.delete(entityId);
-    this.deletedRecordIds.delete(entityId);
-  }
-
-  getEntityById(entityId: EntityId) {
-    return this.collection.get(entityId);
-  }
-
-  filter(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): InstanceType<TEntityConstructor>[] {
-    const result: InstanceType<TEntityConstructor>[] = [];
-    let i = 0;
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      if (predicate(entity, i++)) {
-        result.push(entity);
-      }
-    }
-    return result;
-  }
-
-  find(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): InstanceType<TEntityConstructor> | undefined {
-    let i = 0;
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      if (predicate(entity, i++)) {
-        return entity;
-      }
-    }
-    return undefined;
-  }
-
-  findIndex(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): number {
-    let i = 0;
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      if (predicate(entity, i)) {
-        return i;
-      }
-      i++;
-    }
-    return -1;
-  }
-
-  findLast(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): InstanceType<TEntityConstructor> | undefined {
-    const entities = this.entities;
-    for (let i = entities.length - 1; i >= 0; i--) {
-      const entity = entities[i];
-      if (predicate(entity, i)) {
-        return entity;
-      }
-    }
-    return undefined;
-  }
-
-  findLastIndex(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): number {
-    const entities = this.entities;
-    for (let i = entities.length - 1; i >= 0; i--) {
-      const entity = entities[i];
-      if (predicate(entity, i)) {
-        return i;
-      }
-    }
-    return -1;
-  }
-
-  some(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): boolean {
-    let i = 0;
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      if (predicate(entity, i++)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  every(
-    predicate: (
-      value: InstanceType<TEntityConstructor>,
-      index: number,
-    ) => boolean,
-  ): boolean {
-    let i = 0;
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      if (!predicate(entity, i++)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  map<T>(
-    predicate: (value: InstanceType<TEntityConstructor>, index: number) => T,
-  ): T[] {
-    const result: T[] = [];
-    let i = 0;
-    for (const entity of this.collection.values()) {
-      if (this.deletedRecordIds.has(entity.id)) continue;
-      result.push(predicate(entity, i++));
-    }
-    return observable.array(result);
-  }
-
-  private initQueryClientCacheListener() {
-    this.queryClient.getQueryCache().subscribe((event) => {
-      if (event.type === "removed") {
-        this.removeQueryHashesFromAllEntities([event.query.queryHash]);
-      }
-    });
-  }
-
-  private removeQueryHashesFromAllEntities(hashes: string[]) {
-    for (const entity of this.collection.values()) {
-      entity._removeQueryHashes(hashes);
-    }
-  }
-}

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

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

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

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

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

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

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

@@ -1,105 +0,0 @@
-import type {
-  DefaultError,
-  MutationFunctionContext,
-} from "@tanstack/react-query";
-import type { EntityConstructorAny, EntityCollection } from "../entity";
-import type {
-  BatchMutationInputInternal,
-  UseBatchMutationHookOptions,
-} from "./types";
-import { MutationBase } from "./MutationBase";
-
-export class BatchMutationBase<
-  TEntityConstructor extends EntityConstructorAny,
-  TError = DefaultError,
-  TMutateResult = unknown,
-> extends MutationBase<TEntityConstructor> {
-  protected readonly collection: EntityCollection<TEntityConstructor>;
-
-  constructor(
-    mutationPrefix: string,
-    protected readonly options: UseBatchMutationHookOptions<
-      TEntityConstructor,
-      TError,
-      TMutateResult
-    >,
-  ) {
-    super(mutationPrefix, options.entity);
-
-    this.collection = this.getEntityCollection(options.entity);
-  }
-
-  protected async onMutateBase(
-    input: BatchMutationInputInternal<TEntityConstructor>,
-    context: MutationFunctionContext,
-  ): Promise<TMutateResult> {
-    input.strategy.onMutate();
-    const result = await this.options.onMutate?.(input.entities, context);
-    return result ?? ({} as TMutateResult);
-  }
-
-  protected async onSuccessBase(
-    input: BatchMutationInputInternal<TEntityConstructor>,
-    onMutateResult: TMutateResult | undefined,
-    context: MutationFunctionContext,
-  ): Promise<void> {
-    input.strategy.onSuccess();
-    await this.options.onSuccess?.(input.entities, context, onMutateResult);
-  }
-
-  protected async onErrorBase(
-    error: TError,
-    input: BatchMutationInputInternal<TEntityConstructor>,
-    onMutateResult: TMutateResult | undefined,
-    context: MutationFunctionContext,
-  ): Promise<void> {
-    input.strategy.onError();
-    await this.options.onError?.(
-      error,
-      input.entities,
-      context,
-      onMutateResult,
-    );
-  }
-
-  protected async onSettledBase(
-    error: TError | null,
-    input: BatchMutationInputInternal<TEntityConstructor>,
-    onMutateResult: TMutateResult | undefined,
-    context: MutationFunctionContext,
-  ): Promise<void> {
-    await this.options.onSettled?.(
-      input.entities,
-      context,
-      onMutateResult,
-      error,
-    );
-  }
-
-  protected createInternalInput(
-    entities: InstanceType<TEntityConstructor>[],
-  ): BatchMutationInputInternal<TEntityConstructor> {
-    const dirtyEntities: InstanceType<TEntityConstructor>[] = [];
-
-    for (const entity of entities) {
-      if (!entity.isDirty) {
-        console.warn(
-          "Entity values has not been changed, mutation is skipped.",
-        );
-
-        continue;
-      }
-
-      dirtyEntities.push(entity);
-    }
-
-    return {
-      entities: dirtyEntities,
-      strategy: this.createMutationStrategy(dirtyEntities, {
-        invalidationStrategy: this.options.invalidationStrategy,
-        errorStrategy: this.options.errorStrategy,
-        invalidateOnError: this.options.invalidateOnError,
-      }),
-    };
-  }
-}

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

@@ -1,48 +0,0 @@
-import { type DefaultError, useMutation } from "@tanstack/react-query";
-import type { EntityConstructorAny } from "../entity";
-import { BatchMutationBase } from "./BatchMutationBase";
-import type {
-  BatchMutationInputInternal,
-  UseBatchMutationHookOptions,
-} from "./types";
-
-export 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
-    >,
-  ) {
-    super(BatchUpdateMutation.mutationPrefix, options);
-  }
-
-  useMutation() {
-    const mutation = useMutation<
-      void,
-      TError,
-      BatchMutationInputInternal<TEntityConstructor>,
-      TMutateResult
-    >({
-      mutationFn: (input) =>
-        this.options.mutationFn(input.entities, this.context),
-      onMutate: (input, context) => this.onMutateBase(input, context),
-      onSuccess: (_, input, onMutateResult, context) =>
-        this.onSuccessBase(input, onMutateResult, context),
-      onError: (error, input, onMutateResult, context) =>
-        this.onErrorBase(error, input, onMutateResult, context),
-      onSettled: (_, error, input, onMutateResult, context) =>
-        this.onSettledBase(error, input, onMutateResult, context),
-    });
-
-    return (entities: InstanceType<TEntityConstructor>[]) => {
-      mutation.mutate(this.createInternalInput(entities));
-    };
-  }
-}

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

@@ -1,172 +0,0 @@
-import {
-  type DefaultError,
-  type MutationFunctionContext,
-  useMutation,
-} from "@tanstack/react-query";
-import type { EntityAny, EntityConstructorAny } from "../entity";
-import type {
-  CreateMutationInputInternal,
-  UseCreateMutationHookOptions,
-} from "./types";
-import { action } from "mobx";
-import {
-  OptimisticMutationErrorStrategy,
-  OptimisticMutationInvalidationStrategy,
-} from "./constants";
-import { MutationBase } from "./MutationBase";
-
-export class CreateMutation<
-  TInput,
-  TEntityConstructor extends EntityConstructorAny = EntityConstructorAny,
-  TError = DefaultError,
-  TMutateResult = unknown,
-> extends MutationBase<TEntityConstructor> {
-  static readonly mutationPrefix = "__mutation__create__";
-
-  constructor(
-    private readonly options: UseCreateMutationHookOptions<
-      TInput,
-      TEntityConstructor,
-      TError,
-      TMutateResult
-    >,
-  ) {
-    super(CreateMutation.mutationPrefix, options.entity);
-  }
-
-  useMutation() {
-    const mutation = useMutation<
-      void,
-      TError,
-      CreateMutationInputInternal<TInput, TEntityConstructor>,
-      TMutateResult
-    >({
-      mutationFn: (
-        input: CreateMutationInputInternal<TInput, TEntityConstructor>,
-      ) => this.options.mutationFn(input.input, input.entity, this.context),
-      onMutate: (input, context) => this.onMutate(input, context),
-      onSuccess: (_, input, onMutateResult, context) =>
-        this.onSuccess(input, onMutateResult, context),
-      onError: (error, input, onMutateResult, context) =>
-        this.onError(error, input, onMutateResult, context),
-      onSettled: (_, error, input, onMutateResult, context) =>
-        this.onSettled(input, error, onMutateResult, 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.baseMutationKey,
-    });
-
-    return (input: TInput) => {
-      const entity =
-        new this.options.entity() as InstanceType<TEntityConstructor>;
-      entity.hydrate(input);
-      entity._markAsHydrated();
-
-      this.collection.setEntity(entity);
-      this.collection.clientOnlyEntityIds.add(entity.id);
-
-      mutation.mutate({
-        input,
-        entity,
-        mutationStrategy: this.createMutationStrategy([entity]),
-      });
-    };
-  }
-
-  @action private async onMutate(
-    input: CreateMutationInputInternal<TInput, TEntityConstructor>,
-    context: MutationFunctionContext,
-  ): Promise<TMutateResult> {
-    input.mutationStrategy.onMutate();
-
-    const onMutateResult = await this.options.onMutate?.(
-      input.input,
-      input.entity,
-      context,
-    );
-    return onMutateResult ?? ({} as TMutateResult);
-  }
-
-  @action private onSuccess(
-    input: CreateMutationInputInternal<TInput, TEntityConstructor>,
-    onMutateResult: TMutateResult,
-    context: MutationFunctionContext,
-  ) {
-    input.mutationStrategy.onSuccess();
-
-    // if (this.pendingEntity) {
-    //   this.entityManager.clientOnlyEntityIds.delete(this.pendingEntity.id)
-    // }
-    this.options.onSuccess?.(
-      input.input,
-      input.entity,
-      onMutateResult,
-      context,
-    );
-  }
-
-  @action private onError(
-    error: TError,
-    input: CreateMutationInputInternal<TInput, TEntityConstructor>,
-    onMutateResult: TMutateResult | undefined,
-    context: MutationFunctionContext,
-  ) {
-    const strategy =
-      input.mutationStrategy?.mutationErrorStrategy ??
-      OptimisticMutationErrorStrategy.ROLLBACK;
-    input.mutationStrategy.onError(true);
-
-    if (strategy === OptimisticMutationErrorStrategy.ROLLBACK) {
-      this.collection.deleteEntity(input.entity.id);
-    }
-
-    this.options.onError?.(
-      error,
-      input.input,
-      input.entity,
-      onMutateResult,
-      context,
-    );
-  }
-
-  @action private onSettled(
-    input: CreateMutationInputInternal<TInput, TEntityConstructor>,
-    error: TError | null,
-    onMutateResult: TMutateResult | undefined,
-    context: MutationFunctionContext,
-  ) {
-    this.options.onSettled?.(
-      input.input,
-      input.entity,
-      error,
-      onMutateResult,
-      context,
-    );
-  }
-
-  protected createMutationStrategy(entities: EntityAny[]) {
-    if (
-      this.options.invalidationStrategy ===
-      OptimisticMutationInvalidationStrategy.REFERENCED_QUERIES
-    ) {
-      throw new Error(
-        "REFERENCED_QUERIES invalidation strategy is not supported for create mutation",
-      );
-    }
-
-    const mutationStrategy = super.createMutationStrategy(entities, {
-      invalidationStrategy:
-        this.options.invalidationStrategy ??
-        OptimisticMutationInvalidationStrategy.ALL_ENTITY_QUERIES,
-      errorStrategy: this.options.errorStrategy,
-      invalidateOnError: this.options.invalidateOnError,
-    });
-
-    return mutationStrategy;
-  }
-}