Files
Tom Moor 6231f01860 fix: Forced fetches dropped or stale while another fetch is in flight (#14573)
* fix: Run forced document tree fetches that arrive while a fetch is in flight

* fix: Run forced store fetches that arrive while a fetch is in flight

* test
2026-11-12 23:07:35 -05:00

346 lines
9.7 KiB
TypeScript

import { isEqual, pick } from "es-toolkit/compat";
import { action, makeObservable, observable, toJS } from "mobx";
import type { JSONObject } from "@shared/types";
import type Store from "~/stores/base/Store";
import type { PartialExcept } from "~/types";
import Logger from "~/utils/Logger";
import { getFieldsForModel, getFieldsForModelClass } from "../decorators/Field";
import { LifecycleManager } from "../decorators/Lifecycle";
import { getRelationsForModelClass } from "../decorators/Relation";
/**
* MobX records decorator annotations on the prototype under a symbol with this
* description.
*/
const storedAnnotationsDescription = "mobx-stored-annotations";
/**
* Returns the keys of every decorated member on a model, including those
* inherited from base classes. The nearest record on the prototype chain
* already includes the parents' annotations, so the search stops there.
*
* With `useDefineForClassFields: false` a field declared without an initializer
* never exists on the instance, so MobX cannot annotate it. This helper, and
* the pre-definition in `initialize`, can be removed if that compiler option
* is enabled.
*
* @param target the model to inspect.
* @returns the keys annotated with a MobX decorator.
*/
function getAnnotatedKeysForModel(target: Model): (string | symbol)[] {
let prototype = Object.getPrototypeOf(target);
while (prototype && prototype !== Object.prototype) {
const symbol = Object.getOwnPropertySymbols(prototype).find(
(candidate) => candidate.description === storedAnnotationsDescription
);
if (symbol) {
const annotations: Record<string | symbol, unknown> = Reflect.get(
prototype,
symbol
);
return Reflect.ownKeys(annotations);
}
prototype = Object.getPrototypeOf(prototype);
}
return [];
}
export default abstract class Model {
static modelName: string;
/**
* Restores data written by toPersisted to the shape the model expects,
* discarding any properties that are not declared fields. Records written by
* a different version of the app may not match the current model.
*
* @param record the persisted representation of a model.
* @returns the data to construct or update a model with.
*/
static fromPersisted<T extends Model>(
record: Record<string, unknown>
): PartialExcept<T, "id"> {
const fields = getFieldsForModelClass(this);
return JSON.parse(JSON.stringify(pick(record, ["id", ...fields])));
}
@observable
id: string;
@observable
isSaving = false;
@observable
isNew = false;
@observable
createdAt: string;
@observable
updatedAt: string;
store: Store<Model>;
constructor(_fields: Record<string, unknown>, store: Store<Model>) {
this.store = store;
}
/**
* Applies the initial data and makes the instance observable.
*
* Call this from the constructor of the most-derived class. MobX can only
* annotate fields that already exist on the instance, and a subclass's fields
* do not exist until its own constructor has run.
*
* @param fields the data to construct the model with.
*/
protected initialize(fields: Record<string, unknown>) {
const declared = [
...getFieldsForModel(this),
...getAnnotatedKeysForModel(this),
];
for (const field of declared) {
if (field in this) {
continue;
}
Object.defineProperty(this, field, {
configurable: true,
enumerable: true,
value: undefined,
writable: true,
});
}
this.updateData(fields);
this.isNew = !this.id;
makeObservable(this);
this.initialized = true;
}
/**
* Ensures all the defined relations and policies for the model are in memory.
*
* @returns A promise that resolves when loading is complete.
*/
async loadRelations(
this: Model,
options: { withoutPolicies?: boolean } = {}
): Promise<unknown> {
return this.store.relationFetches.run(this.id, () => {
const promises = [];
const relations = getRelationsForModelClass(
this.constructor as typeof Model
);
if (relations) {
for (const properties of relations.values()) {
const store = this.store.rootStore.getStoreForModelName(
properties.relationClassResolver().modelName
);
if ("canFetchById" in store && store.canFetchById) {
const id = this[properties.idKey];
if (id) {
promises.push(store.fetch(id as string));
}
}
}
}
const policy = this.store.rootStore.policies.get(this.id);
if (!policy && !options.withoutPolicies && this.store.canFetchById) {
promises.push(this.store.fetch(this.id, { force: true }));
}
return Promise.all(promises);
});
}
/**
* Persists the model to the server API
*
* @param params Specific fields to save, if not provided the model will be serialized
* @param options Options to pass to the store
* @returns A promise that resolves with the updated model
*/
save = async (
params?: Record<string, unknown>,
options?: Record<string, string | boolean | number | undefined>
): Promise<Model> => {
const isNew = this.isNew;
this.isSaving = true;
try {
// ensure that the id is passed if the document has one
if (!params) {
params = this.toAPI();
}
if (isNew) {
LifecycleManager.executeHooks(this.constructor, "beforeCreate", this);
} else {
LifecycleManager.executeHooks(this.constructor, "beforeUpdate", this);
}
const model = await this.store.save(
{
...params,
id: this.id,
},
{
...options,
isNew,
}
);
// if saving is successful set the new values on the model itself
this.updateData(Object.assign({}, params, model));
if (isNew) {
LifecycleManager.executeHooks(this.constructor, "afterCreate", this);
} else {
LifecycleManager.executeHooks(this.constructor, "afterUpdate", this);
}
return model;
} finally {
this.isSaving = false;
}
};
updateData = action((data: Record<string, unknown>) => {
if (this.initialized) {
LifecycleManager.executeHooks(this.constructor, "beforeChange", this);
}
const previousAttributes = this.toAPI();
let addedKeys = false;
for (const key in data) {
try {
// Some models are serialized with the initialized flag, this should be ignored.
if (key === "initialized") {
continue;
}
if (isEqual(toJS(Reflect.get(this, key)), data[key])) {
continue;
}
// A field declared without a default does not exist until it is first
// assigned, so MobX could not annotate it when the model was created.
addedKeys ||= !(key in this);
Reflect.set(this, key, data[key]);
} catch (error) {
Logger.warn(`Error setting ${key} on model`, { error });
}
}
// Annotate any field that this payload introduced. Re-annotating a field
// that is already observable is a no-op.
if (addedKeys && this.initialized) {
makeObservable(this);
}
this.isNew = false;
this.persistedAttributes = this.toAPI();
if (this.initialized) {
LifecycleManager.executeHooks(
this.constructor,
"afterChange",
this,
previousAttributes
);
}
});
fetch = (options?: JSONObject) => this.store.fetch(this.id, options);
refresh = () =>
this.fetch({
force: true,
});
delete = async () => {
this.isSaving = true;
try {
LifecycleManager.executeHooks(this.constructor, "beforeDelete", this);
const response = await this.store.delete(this);
LifecycleManager.executeHooks(this.constructor, "afterDelete", this);
return response;
} finally {
this.isSaving = false;
}
};
/**
* Returns a plain object representation of fields on the model for
* persistence to the server API
*
* @returns A plain object representation of the model
*/
toAPI = (): Partial<Model> => {
const fields = getFieldsForModel(this);
return pick(this, fields);
};
/**
* Returns a plain object representation of the model, containing its
* identifier and declared fields only, safe to store outside of memory.
* Internal state and observables are not included.
*
* @returns A plain object representation of the model
*/
toPersisted = (): PartialExcept<Model, "id"> =>
JSON.parse(JSON.stringify({ ...this.toAPI(), id: this.id }));
/**
* Returns a plain object representation of all the properties on the model
* overrides the native toJSON method to avoid attempting to serialize store
*
* @returns A plain object representation of the model
*/
toJSON() {
const output: Partial<typeof this> = {};
for (const property in this) {
if (
// oxlint-disable-next-line no-prototype-builtins
this.hasOwnProperty(property) &&
!["persistedAttributes", "store", "isSaving", "isNew"].includes(
property
)
) {
output[property] = this[property];
}
}
return output;
}
/**
* Returns a boolean indicating if the model has changed since it was last
* persisted to the server
*
* @returns boolean true if unsaved
*/
isDirty(): boolean {
const attributes = this.toAPI();
if (Object.keys(attributes).length === 0) {
Logger.warn("Checking dirty on model with no @Field decorators");
}
return (
JSON.stringify(this.persistedAttributes) !== JSON.stringify(attributes)
);
}
protected persistedAttributes: Partial<Model> = {};
/** A boolean representing if the constructor has been called. */
private initialized = false;
}