@elyx-code/editor-ui 0.0.2

package/src/services/editor/value-store.ts

@@ -0,0 +1,619 @@
+import {
+	ILiteralValue,
+	ILiteralValueTransfer,
+	DataTypeState,
+	EntityWithValueState,
+	InputMapState,
+	ProjectState,
+	LiteralValueState,
+	createStateFromType,
+	Reference,
+	EntityId,
+} from '@elyx-code/project-logic-tree';
+import { getLiteralValueNameFromDataType } from '../execution/utils';
+import { hydrateOrDiscardLiteralValue } from '../execution/value-resolution';
+import { Logger } from '@elyx-code/common-ts-utils';
+
+export enum DynamicValueTypes {
+	// --- Input values ---
+
+	/*
+		This value is inherited from another variable that has this value resolved or hardcoded
+		If there are no breaks in the chain, we can deduce what the value will be in other entities, which we call "inheritance chain"
+	*/
+	Inherited = 'inherited',
+
+	/*
+		This is the value that the entity takes by default when it is instanciated, if no other value is provided
+	*/
+	DefaultValue = 'default-value',
+
+	/*
+		A empty value that is deemed required for the code to work:
+			- Could be an entry point external value when a test is being run, in which case the user needs to provide it
+			- Could be a value that is the first in the inheritance chain to be required and has inherited no value
+	*/
+	Missing = 'missing',
+
+	/*
+		This is a value that should be provided by the user, but has not been provided yet
+		It is different from 'missing' because it is not required for the code to work, so it can be left as is,
+		different from 'empty' because it is not explicitly empty, but it is just not provided yet
+	*/
+	Undefined = 'undefined',
+
+	/*
+		A value that is empty, but it is not required for the code to work so it can be left empty
+		Equivalent to 'null' in JavaScript,
+		Explicitly empty rather than the value not being provided, which is the case of 'undefined',
+		Also means that the data-type of the value needs to support 'null'
+	*/
+	Empty = 'empty',
+
+	// --- Output values ---
+
+	/*
+		This is usually a value resulting from an operation,
+		simple operations that require no server-side logic, special permissions, or a lot of compute power
+		can be executed in the browser and shown to the user to help them debug their logic in the moment
+	*/
+	AutoCalculated = 'auto-calculated',
+
+	/*
+		Some values are too complex to be calculated in the browser,
+		they require server-side logic, special permissions, or a lot of compute power
+		So we indicate that this values will be calculated when the logic runs, so we can do validation without having the actual value
+	*/
+	QueuedAutocalculation = 'queued-autocalculation',
+
+	/*
+		This is a value that will be passed at runtime, when the project is deployed and running
+		For example, the data to an endpoint in an API call
+		They are often used as the arguments of function declarations or events, since when they are used they are passed values
+		But when tested in isolation, we need to provide them because they are external to the declaration
+	*/
+	External = 'external',
+
+	// --- Testing values ---
+
+	/*
+		This is a value used only to test the logic of the project,
+		it is not used in production, they are ignored during deployment
+	*/
+	Testing = 'testing',
+
+	/*
+		These are values that are returned from a test,
+		at the end of the execution of an operation or function,
+		they are efimeral, so we lose them after the execution of a test is done
+	*/
+	ExecutionResult = 'execution-result',
+}
+
+export interface IValueInheritanceLink {
+	sources: IDynamicValue[];
+	target: EntityWithValueState;
+}
+
+export interface IDynamicValue {
+	value: LiteralValueState | null;
+	valueOwner: EntityWithValueState;
+	type: DynamicValueTypes;
+	inheritanceLink: IValueInheritanceLink | null;
+}
+
+export interface IValueStoreRecord {
+	// Value owner entity id (not by literal value id)
+	[key: EntityId]: LiteralValueState;
+}
+
+export interface IValueStoreClient {
+	initialized: boolean;
+	id: string;
+	project: ProjectState;
+	values: IValueStoreRecord;
+	onWriteCallback: (owner: EntityWithValueState, value: ILiteralValue) => void;
+	onRemoveCallback: (owner: EntityWithValueState) => void;
+	onWrite(
+		callback: (owner: EntityWithValueState, value: ILiteralValue) => void
+	): void;
+	onRemove(callback: (owner: EntityWithValueState) => void): void;
+	init(): void;
+	toJSON(): {
+		[key: string]: ILiteralValueTransfer;
+	};
+	writeValue(owner: EntityWithValueState, value: LiteralValueState): void;
+	readValue(ownerId: string): LiteralValueState | null;
+	removeValue(ownerId: string): void;
+	clear(): void;
+}
+
+export const PLACEHOLDER_VALUE_STORE_CLIENT: IValueStoreClient = {
+	initialized: false,
+	id: '',
+	project: null as unknown as ProjectState,
+	values: {},
+	onWriteCallback: () => {},
+	onRemoveCallback: () => {},
+	onWrite: () => {},
+	onRemove: () => {},
+	init: () => {},
+	toJSON: () => ({}),
+	writeValue: () => {},
+	readValue: () => null,
+	removeValue: () => {},
+	clear: () => {},
+};
+
+export function generatePlaceholderValueStore(
+	id: string,
+	project: ProjectState
+): IValueStoreClient {
+	return {
+		...PLACEHOLDER_VALUE_STORE_CLIENT,
+		id,
+		project,
+	};
+}
+
+export class EfimeralValueStore implements IValueStoreClient {
+	initialized = false;
+	id: string;
+	project: ProjectState;
+	values: IValueStoreRecord = {};
+
+	onWriteCallback: (owner: EntityWithValueState, value: ILiteralValue) => void =
+		() => {};
+	onRemoveCallback: (owner: EntityWithValueState) => void = () => {};
+
+	constructor(id: string, project: ProjectState) {
+		this.id = id;
+		this.project = project;
+		this.init();
+	}
+
+	// Set a callback to be called when a value is written
+	onWrite(
+		callback: (owner: EntityWithValueState, value: ILiteralValue) => void
+	) {
+		this.onWriteCallback = callback;
+	}
+
+	onRemove(callback: (owner: EntityWithValueState) => void) {
+		this.onRemoveCallback = callback;
+	}
+
+	// Pre-load values from local storage based on project id
+	init() {
+		if (!this.project.id || this.initialized) {
+			return;
+		}
+
+		const parsedValues: {
+			[key: EntityId]: ILiteralValueTransfer;
+		} = {};
+
+		const instanciatedValue: {
+			// Value owner entity id
+			[key: string]: LiteralValueState;
+		} = {};
+
+		// Turn each object value into a 'LiteralValueState' class instance
+		Object.keys(parsedValues).forEach((key) => {
+			const value: ILiteralValueTransfer = parsedValues[key];
+			const newInstance = new LiteralValueState(value, this.project);
+
+			try {
+				if (value.parent) {
+					// Find and set parents
+					const parentInstance =
+						this.project.findSubscribedInstanceFromReference(
+							value.parent as Reference
+						) as DataTypeState | InputMapState;
+
+					if (!parentInstance) {
+						return;
+					}
+
+					newInstance.setParent(parentInstance, null);
+					newInstance.hydrateAncestors();
+					newInstance.initChildren(null);
+				} else if (value.standaloneParent) {
+					const parentInstance =
+						this.project.findSubscribedInstanceFromReference(
+							value.standaloneParent as Reference
+						) as EntityWithValueState;
+
+					if (!parentInstance) {
+						return;
+					}
+
+					newInstance.standalone = true;
+					newInstance.setStandaloneParent(parentInstance, null);
+					newInstance.hydrateAncestors();
+					newInstance.initChildren(null);
+				}
+
+				instanciatedValue[key] = newInstance;
+
+				const parent = (newInstance.parent ||
+					newInstance.standaloneParent) as EntityWithValueState;
+
+				// Hydrate or discard the value
+				const result = hydrateOrDiscardLiteralValue(
+					newInstance,
+					parent,
+					this.project
+				);
+
+				if (result) {
+					instanciatedValue[key] = result;
+				} else {
+					// Remove the value from local storage
+					delete parsedValues[key];
+				}
+			} catch (e) {
+				Logger.error('Error hydrating ancestors: ', e);
+				// Remove the value from local storage
+				delete parsedValues[key];
+			}
+		});
+
+		this.values = {
+			...this.values,
+			...instanciatedValue,
+		};
+
+		this.initialized = true;
+	}
+
+	toJSON(): {
+		[key: string]: ILiteralValueTransfer;
+	} {
+		// Loop over each value and apply the '.toJSON()' method
+		const values: {
+			[key: string]: ILiteralValueTransfer;
+		} = {};
+
+		Object.keys(this.values).forEach((key) => {
+			values[key] = this.values[key].toJSON() as ILiteralValueTransfer;
+		});
+
+		return values;
+	}
+
+	writeValue(owner: EntityWithValueState, value: LiteralValueState) {
+		if (!owner) {
+			throw new Error(
+				`The value owner entity is required when writing a value to a value store`
+			);
+		}
+
+		// find existing instace or create new ones
+		const existingInstance = this.values[owner.id];
+
+		let instance = existingInstance;
+
+		if (!instance) {
+			if (value instanceof LiteralValueState) {
+				instance = value;
+			} else if (!!value) {
+				instance = createStateFromType(
+					value,
+					this.project
+				) as LiteralValueState;
+			} else {
+				// Create new literal value transfer and instance from the owner data type
+				// And set the value to null
+				const newLiteralValueTransfer: ILiteralValueTransfer =
+					LiteralValueState.new(null);
+				newLiteralValueTransfer.standaloneParent = (
+					owner as EntityWithValueState
+				).toReference();
+				newLiteralValueTransfer.name = getLiteralValueNameFromDataType(
+					owner.getDataType(null)
+				);
+
+				instance = createStateFromType(
+					newLiteralValueTransfer,
+					this.project
+				) as LiteralValueState;
+			}
+		}
+
+		instance.standalone = true;
+
+		if (!instance.initialData.standaloneParent) {
+			Logger.warn('instance.initialData: ', instance.initialData);
+		}
+
+		instance.setStandaloneParent(owner as EntityWithValueState, null);
+		instance.hydrateAncestors();
+		instance.initChildren(null);
+
+		if (!!value) {
+			instance.metaSync(
+				{
+					...value,
+				},
+				null
+			);
+
+			instance.setValueAsType(value.valueAsType, null);
+		}
+
+		this.values[owner.id] = instance;
+
+		this.onWriteCallback(owner as EntityWithValueState, instance);
+	}
+
+	readValue(ownerId: string): LiteralValueState | null {
+		return this.values[ownerId] || null;
+	}
+
+	removeValue(ownerId: string) {
+		if (!this.values[ownerId]) {
+			return;
+		}
+
+		delete this.values[ownerId];
+
+		const owner = this.project.get(ownerId) as EntityWithValueState;
+
+		if (!!owner) {
+			this.onRemoveCallback(owner);
+		}
+	}
+
+	// Clear all values
+	clear() {
+		this.values = {};
+	}
+}
+
+export class LocalBrowserValueStore implements IValueStoreClient {
+	initialized = false;
+	id: string;
+	project: ProjectState;
+	values: IValueStoreRecord = {};
+
+	onWriteCallback: (owner: EntityWithValueState, value: ILiteralValue) => void =
+		() => {};
+	onRemoveCallback: (owner: EntityWithValueState) => void = () => {};
+
+	constructor(id: string, project: ProjectState) {
+		this.id = id;
+		this.project = project;
+		this.init();
+	}
+
+	// Set a callback to be called when a value is written
+	onWrite(
+		callback: (owner: EntityWithValueState, value: ILiteralValue) => void
+	) {
+		this.onWriteCallback = callback;
+	}
+
+	onRemove(callback: (owner: EntityWithValueState) => void) {
+		this.onRemoveCallback = callback;
+	}
+
+	// Pre-load values from local storage based on project id
+	init() {
+		if (!this.project.id || this.initialized) {
+			return;
+		}
+
+		const values = localStorage.getItem(this.id);
+
+		if (!values) {
+			// Initialize with empty object
+			localStorage.setItem(this.id, JSON.stringify(this.values));
+		}
+
+		const parsedValues = JSON.parse(values || '{}');
+
+		const instanciatedValue: {
+			// Value owner entity id
+			[key: string]: LiteralValueState;
+		} = {};
+
+		// Turn each object value into a 'LiteralValueState' class instance
+		Object.keys(parsedValues).forEach((key) => {
+			const value: ILiteralValueTransfer = parsedValues[key];
+			const newInstance = new LiteralValueState(value, this.project);
+
+			try {
+				if (value.parent) {
+					// Find and set parents
+					const parentInstance =
+						this.project.findSubscribedInstanceFromReference(
+							value.parent as Reference
+						) as DataTypeState | InputMapState;
+
+					if (!parentInstance) {
+						return;
+					}
+
+					newInstance.setParent(parentInstance, null);
+					newInstance.hydrateAncestors();
+					newInstance.initChildren(null);
+				} else if (value.standaloneParent) {
+					const parentInstance =
+						this.project.findSubscribedInstanceFromReference(
+							value.standaloneParent as Reference
+						) as EntityWithValueState;
+
+					if (!parentInstance) {
+						return;
+					}
+
+					newInstance.standalone = true;
+					newInstance.setStandaloneParent(parentInstance, null);
+					newInstance.hydrateAncestors();
+					newInstance.initChildren(null);
+				}
+
+				instanciatedValue[key] = newInstance;
+
+				const parent = (newInstance.parent ||
+					newInstance.standaloneParent) as EntityWithValueState;
+
+				// Hydrate or discard the value
+				const result = hydrateOrDiscardLiteralValue(
+					newInstance,
+					parent,
+					this.project
+				);
+
+				if (result) {
+					instanciatedValue[key] = result;
+				} else {
+					// Remove the value from local storage
+					delete parsedValues[key];
+				}
+			} catch (e) {
+				Logger.error('Error hydrating ancestors: ', e);
+				// Remove the value from local storage
+				delete parsedValues[key];
+			}
+		});
+
+		this.values = {
+			...this.values,
+			...instanciatedValue,
+		};
+
+		this.initialized = true;
+	}
+
+	toJSON(): {
+		[key: string]: ILiteralValueTransfer;
+	} {
+		// Loop over each value and apply the '.toJSON()' method
+		const values: {
+			[key: string]: ILiteralValueTransfer;
+		} = {};
+
+		Object.keys(this.values).forEach((key) => {
+			values[key] = this.values[key].toJSON() as ILiteralValueTransfer;
+		});
+
+		return values;
+	}
+
+	writeValue(owner: EntityWithValueState, value: LiteralValueState) {
+		if (!owner) {
+			throw new Error(
+				`The value owner entity is required when writing a value to a value store`
+			);
+		}
+
+		// find existing instace or create new ones
+		const existingInstance = this.values[owner.id];
+
+		let instance = existingInstance;
+
+		if (!instance) {
+			if (value instanceof LiteralValueState) {
+				instance = value;
+			} else if (!!value) {
+				instance = createStateFromType(
+					value,
+					this.project
+				) as LiteralValueState;
+			} else {
+				// Create new literal value transfer and instance from the owner data type
+				// And set the value to null
+				const newLiteralValueTransfer: ILiteralValueTransfer =
+					LiteralValueState.new(null);
+				newLiteralValueTransfer.standaloneParent = (
+					owner as EntityWithValueState
+				).toReference();
+				newLiteralValueTransfer.name = getLiteralValueNameFromDataType(
+					owner.getDataType(null)
+				);
+
+				instance = createStateFromType(
+					newLiteralValueTransfer,
+					this.project
+				) as LiteralValueState;
+			}
+		}
+
+		instance.standalone = true;
+
+		if (!instance.initialData.standaloneParent) {
+			Logger.warn('instance.initialData: ', instance.initialData);
+		}
+
+		instance.setStandaloneParent(owner as EntityWithValueState, null);
+		instance.hydrateAncestors();
+		instance.initChildren(null);
+
+		if (!!value) {
+			instance.metaSync(
+				{
+					...value,
+				},
+				null
+			);
+
+			instance.setValueAsType(value.valueAsType, null);
+		}
+
+		this.values[owner.id] = instance;
+
+		const json = this.toJSON();
+
+		const stringifiedValue = JSON.stringify(json);
+
+		try {
+			// Save to local storage
+			localStorage.setItem(this.id, stringifiedValue);
+		} catch (e) {
+			// Sometimes memory can be full
+			Logger.error('Error saving to local storage: ', e);
+		}
+
+		this.onWriteCallback(owner as EntityWithValueState, instance);
+	}
+
+	readValue(ownerId: string): LiteralValueState | null {
+		return this.values[ownerId] || null;
+	}
+
+	removeValue(ownerId: string) {
+		if (!this.values[ownerId]) {
+			return;
+		}
+
+		delete this.values[ownerId];
+
+		const stringifiedValue = JSON.stringify(this.toJSON());
+
+		// Save to local storage
+		localStorage.setItem(this.id, stringifiedValue);
+
+		const owner = this.project.get(ownerId) as EntityWithValueState;
+
+		if (!!owner) {
+			this.onRemoveCallback(owner);
+		}
+	}
+
+	// Clear all values
+	clear() {
+		this.values = {};
+		localStorage.removeItem(this.id);
+	}
+
+	teardown() {
+		this.values = {};
+		this.initialized = false;
+
+		// Remove all callbacks
+		this.onWriteCallback = () => {};
+		this.onRemoveCallback = () => {};
+	}
+}