mirror of
https://github.com/outline/outline.git
synced 2026-11-22 14:01:41 +03:00
* feat: Persist policies to IndexedDB so abilities survive reload Adds a StorePersistence layer that caches a store's models in IndexedDB and hydrates them back at boot as stale data, revalidated by normal API traffic. Enabled for the policies store, scoped per team, so cached abilities are available immediately after a reload instead of every policy needing a forced refetch. - Persistence hooks in the base Store add/remove/clear methods, since add() updates existing models in place and map observation would miss those changes - Enabled from RootStore construction (team read from localStorage) and again after auth.info succeeds to cover the first session after login - Store.clear() wipes the persisted records, covering both logout paths - deleteAllDatabases() fallback removes the policies database on browsers without indexedDB.databases() Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XisV6sRdexfnPSiehurKoV * refactor: Opt stores into persistence via a persistable property Stores now declare persistence with `persistable = true` and RootStore sweeps all persistable stores, deriving each database name from the store's apiEndpoint, instead of RootStore hard-coding the policies store. The deleteAllDatabases fallback uses the same sweep. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XisV6sRdexfnPSiehurKoV * refactor: Simplify store persistence enablement and clearing - Move the persistable guard into Store.enablePersistence so RootStore can call it unconditionally on every store - StorePersistence derives its own database name from the store and teamId rather than receiving a prebuilt name - StorePersistence.clear returns a promise, making the test deterministic instead of sleeping Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XisV6sRdexfnPSiehurKoV * fix: Avoid re-persisting hydrated records, await clear transaction Hydration called store.add() for every cached record, which now triggers persist() and scheduled a flush that wrote the just-loaded data straight back to IndexedDB at boot. Guard persist() with a hydrating flag. clear() awaited the objectStore.clear() request rather than the enclosing transaction, so it could resolve before commit and miss abort errors. * lock * iterate --------- Co-authored-by: Claude <noreply@anthropic.com>
280 lines
7.6 KiB
TypeScript
280 lines
7.6 KiB
TypeScript
import { isEqual, pick } from "es-toolkit/compat";
|
||
import { observable, action, 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";
|
||
|
||
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: boolean;
|
||
|
||
@observable
|
||
isNew: boolean;
|
||
|
||
@observable
|
||
createdAt: string;
|
||
|
||
@observable
|
||
updatedAt: string;
|
||
|
||
store: Store<Model>;
|
||
|
||
constructor(fields: Record<string, unknown>, store: Store<Model>) {
|
||
this.store = store;
|
||
this.updateData(fields);
|
||
this.isNew = !this.id;
|
||
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> {
|
||
// this is to ensure that multiple loads don’t happen in parallel
|
||
if (this.loadingRelations) {
|
||
return this.loadingRelations;
|
||
}
|
||
|
||
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 }));
|
||
}
|
||
|
||
try {
|
||
this.loadingRelations = Promise.all(promises);
|
||
return await this.loadingRelations;
|
||
} finally {
|
||
this.loadingRelations = undefined;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 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();
|
||
|
||
for (const key in data) {
|
||
try {
|
||
// Some models are serialized with the initialized flag, this should be ignored.
|
||
if (key === "initialized") {
|
||
continue;
|
||
}
|
||
// @ts-expect-error TODO
|
||
if (isEqual(toJS(this[key]), data[key])) {
|
||
continue;
|
||
}
|
||
// @ts-expect-error TODO
|
||
this[key] = data[key];
|
||
} catch (error) {
|
||
Logger.warn(`Error setting ${key} on model`, { error });
|
||
}
|
||
}
|
||
|
||
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 promise that resolves when all relations have been loaded. */
|
||
private loadingRelations: Promise<unknown[]> | undefined;
|
||
|
||
/** A boolean representing if the constructor has been called. */
|
||
private initialized = false;
|
||
}
|