@elyx-code/editor-ui 0.0.2

package/src/services/local-relational-database/index.ts

@@ -0,0 +1,3308 @@
+import {
+	BUILT_IN_BASE_ENTITY_IDS,
+	BaseEntityNames,
+	EntityType,
+	ProjectStateEvents,
+	SearchState,
+	checkHasBaseEntity,
+	checkIsEmptyValue,
+	getColumnProperties,
+	getDatabaseEntity,
+	lowercaseFirstLetter,
+	resolvePersistedDefinitionEntityDatabaseEntity,
+	searchStatementDefs,
+	PrimitiveTypes,
+	InputMapState,
+	DefinitionEntityState,
+	PropertyState,
+	resolveEntityName,
+	toCamelCase,
+	toPascalCase,
+	SQLAST as SQLASTLib,
+	searchStatementState as searchStatementStateLib,
+	searchStatementUtils
+} from '@elyx-code/project-logic-tree';
+import {
+	Connection as BaseConnection,
+	IDataBase,
+	IInsertQuery,
+	IOrderQuery,
+	IRemoveQuery,
+	ISelectQuery,
+	ITable,
+	IUpdateQuery
+} from 'jsstore';
+import {
+	persistedDefinitionEntityToDBTableConfig,
+	resolveForeignKeyInfo
+} from './utils';
+import { initLocalDBConnection, initLocalIndexedDatabase } from './idb_helper';
+import {
+	fromOrderByClauseToJsStore,
+	fromWhereClauseToJsStoreWhereObject,
+	getJoinClausesFromSelectStatement,
+	getAllSelectedColumnNamesFromSelectClause
+} from '../database';
+import { EditorService } from '../editor';
+import { IDynamicValue } from '../editor/value-store';
+
+const { ColumnRef, WhereStatement, DataSource, AggregationStatement } =
+	searchStatementStateLib;
+
+const {
+	SearchStatementNodeType,
+	AggregationStatementType,
+	SortStatementDirection,
+	WhereStatementOperator,
+	SQLFunctionCategory,
+	DataSourceType
+} = searchStatementDefs;
+
+type AggregationStatement = searchStatementStateLib.AggregationStatement;
+type ColumnRef = searchStatementStateLib.ColumnRef;
+type DataSource = searchStatementStateLib.DataSource;
+type SearchStatementState = searchStatementStateLib.SearchStatementState;
+type WhereStatement = searchStatementStateLib.WhereStatement;
+type SearchNode = searchStatementStateLib.SearchNode;
+type FunctionCall = searchStatementStateLib.FunctionCall;
+
+type Program = SQLASTLib.Program;
+type SelectStmt = SQLASTLib.SelectStmt;
+type LimitClause = SQLASTLib.LimitClause;
+type WhereStatementOperator = searchStatementDefs.WhereStatementOperator;
+type SortStatementDirection = searchStatementDefs.SortStatementDirection;
+type AggregationStatementType = searchStatementDefs.AggregationStatementType;
+
+export async function describeExisting(
+	dbIdentifier: string
+): Promise<IDataBase | null> {
+	return new Promise((resolve, reject) => {
+		const request = indexedDB.open(dbIdentifier);
+
+		request.onsuccess = (event) => {
+			const db = (event.target as any).result;
+			// console.log('Object store names:', [...db.objectStoreNames]);
+
+			const finalDef: IDataBase = {
+				name: dbIdentifier,
+				tables: [] as ITable[],
+				version: db.version
+			};
+
+			// Iterate over each object store to inspect its properties
+			for (const storeName of db.objectStoreNames) {
+				const transaction = db.transaction(storeName, 'readonly');
+				const objectStore = transaction.objectStore(storeName);
+				// console.log(`Object store: ${storeName}`);
+				// console.log('  Key path:', objectStore.keyPath);
+				// console.log('  Auto increment:', objectStore.autoIncrement);
+				// console.log('  Indexes:', [...objectStore.indexNames]);
+
+				const columns: ITable['columns'] = {};
+
+				// Iterate over each index to inspect its properties
+				for (const indexName of objectStore.indexNames) {
+					const index = objectStore.index(indexName);
+					// console.log(`  Index: ${indexName}`);
+					// console.log('    Key path:', index.keyPath);
+					// console.log('    Unique:', index.unique);
+
+					columns[indexName] = {
+						primaryKey: index.keyPath === objectStore.keyPath,
+						autoIncrement: index.autoIncrement,
+						unique: index.unique,
+						notNull: false,
+						dataType: 'string',
+						default: null,
+						multiEntry: false,
+						enableSearch: false,
+						keyPath: index.keyPath
+					};
+				}
+
+				finalDef.tables.push({
+					name: storeName,
+					columns: columns
+				});
+			}
+			db.close();
+			resolve(finalDef);
+		};
+
+		request.onerror = (event) => {
+			console.error(
+				'Error opening database:',
+				(event.target as any).error
+			);
+			resolve(null);
+		};
+	});
+}
+
+export const toLower = SQLASTLib.cstVisitor({
+	keyword: (kw) => {
+		kw.text = kw.text.toLowerCase();
+	}
+});
+
+export interface Connection extends BaseConnection {
+	$sql: {
+		run: (sql: string) => Promise<any>;
+	};
+}
+
+export interface ISelectQueryResult {
+	columns: searchStatementUtils.IColumnMapping[];
+	rows: {
+		[columnName: string]: any;
+	}[];
+	tableName: string | null;
+	entity: DefinitionEntityState | null;
+	// Total number of rows in the table
+	total: number;
+}
+
+export interface ISelectQueryResultV2 {
+	columns: (ColumnRef | FunctionCall)[];
+	rows: {
+		[columnName: string]: any;
+	}[];
+	tableName: string | null;
+	entity: DefinitionEntityState | null;
+	// Total number of rows in the table
+	total: number;
+}
+
+export interface IDataBaseDetails {
+	items: Table[];
+	// Data for the initial query
+	data: ISelectQueryResult;
+	// Total number of rows in the database
+	total: number;
+}
+
+// This entity puts the table name and property entity that represents it in the canvas under one object
+export class Column implements searchStatementUtils.IColumn {
+	columnName: string;
+	property: PropertyState;
+
+	// Table that this column class instance is stored in
+	table: Table;
+	// Table in which this column can actually be found in the latest version of the database
+	actualTable: Table;
+
+	constructor(columnName: string, property: PropertyState, table: Table) {
+		this.table = table;
+		this.columnName = columnName;
+		this.property = property;
+	}
+
+	get primaryKey(): boolean {
+		const builtInPrimaryKeyPropertyId =
+			BUILT_IN_BASE_ENTITY_IDS[EntityType.BuiltInBaseEntity][
+				BaseEntityNames.PERSISTED_ENTITY
+			].properties.primaryKey.id;
+
+		const isPrimaryKey =
+			this.property.id === builtInPrimaryKeyPropertyId ||
+			!!this.property.implements.find(
+				(impl) => impl.id === builtInPrimaryKeyPropertyId
+			);
+
+		return isPrimaryKey;
+	}
+}
+
+// This entity puts the table name and entity that represents it in the canvas under one object
+export class Table implements searchStatementUtils.ITable {
+	tableName: string;
+	entity: DefinitionEntityState;
+	columns: Column[] = [];
+
+	// Total number of rows in the table
+	total: number = 0;
+
+	// Database
+	database: Database;
+
+	constructor(
+		tableName: string,
+		entity: DefinitionEntityState,
+		database: Database
+	) {
+		this.database = database;
+		this.tableName = tableName;
+		this.entity = entity;
+	}
+
+	async init(): Promise<void> {
+		await this.updateTotal();
+
+		const columnProperties = getColumnProperties(this.entity);
+
+		// Loop over properties and add one key for each in the 'columns' property of the table
+		columnProperties.forEach((property) => {
+			const columnName =
+				property.codeName ||
+				lowercaseFirstLetter(
+					toCamelCase(
+						resolveEntityName(property, this.entity.project)
+					)
+				);
+
+			const existingColumn = this.columns.find(
+				(column) => column.columnName === columnName
+			);
+
+			if (existingColumn) {
+				return;
+			}
+
+			this.columns.push(new Column(columnName, property, this));
+		});
+	}
+
+	// Gets the total number of rows in the table and sets it to the 'total' property
+	async updateTotal(): Promise<number> {
+		const oldTotal = this.total;
+
+		const rows = await this.database.select({
+			from: this.tableName
+		});
+
+		this.total = rows.length;
+
+		const difference = this.total - oldTotal;
+
+		// Add the difference to the total of the parent database
+		this.database.total += difference;
+
+		return this.total;
+	}
+}
+
+function areValuesEqual(left: any, right: any): boolean {
+	if (left === right) {
+		return true;
+	}
+	if (
+		left === null ||
+		left === undefined ||
+		right === null ||
+		right === undefined
+	) {
+		return left === right;
+	}
+	// Numeric coercion for comparison
+	if (typeof left === 'number' && typeof right === 'string') {
+		const rightNum = Number(right);
+		return !isNaN(rightNum) && right !== '' && left === rightNum;
+	}
+	if (typeof left === 'string' && typeof right === 'number') {
+		const leftNum = Number(left);
+		return !isNaN(leftNum) && left !== '' && leftNum === right;
+	}
+	// Boolean-string coercion
+	if (typeof left === 'boolean' && typeof right === 'string') {
+		return String(left) === right;
+	}
+	if (typeof left === 'string' && typeof right === 'boolean') {
+		return left === String(right);
+	}
+	return false;
+}
+
+function coerceToComparable(left: any, right: any): [any, any] {
+	if (typeof left === 'number' && typeof right === 'string') {
+		const rightNum = Number(right);
+		if (!isNaN(rightNum) && right !== '') {
+			return [left, rightNum];
+		}
+	}
+	if (typeof left === 'string' && typeof right === 'number') {
+		const leftNum = Number(left);
+		if (!isNaN(leftNum) && left !== '') {
+			return [leftNum, right];
+		}
+	}
+	return [left, right];
+}
+
+function sanitizeValueForColumn(value: any, column: Column): any {
+	if (checkIsEmptyValue(value)) {
+		return null;
+	}
+	const dataType = column.property.dataType;
+	if (dataType?.entity?.type === EntityType.PrimitiveEntity) {
+		switch (dataType.entity.name) {
+			case PrimitiveTypes.Number: {
+				const num = Number(value);
+				return isNaN(num) ? null : num;
+			}
+			case PrimitiveTypes.Boolean:
+				return value === 'true' || value === true;
+		}
+	} else if (dataType?.entity?.type === EntityType.DefinitionEntity) {
+		const builtInPrimaryKeyPropertyId =
+			BUILT_IN_BASE_ENTITY_IDS[EntityType.BuiltInBaseEntity][
+				BaseEntityNames.PERSISTED_ENTITY
+			].properties.primaryKey.id;
+
+		const referencedProperties = getColumnProperties(
+			dataType.entity as DefinitionEntityState
+		);
+		const primaryKeyProperty = referencedProperties.find((prop) => {
+			return (
+				prop.id === builtInPrimaryKeyPropertyId ||
+				!!prop.implements.find(
+					(impl) => impl.id === builtInPrimaryKeyPropertyId
+				)
+			);
+		});
+
+		if (primaryKeyProperty) {
+			const pkDataType = primaryKeyProperty.dataType;
+			if (
+				pkDataType?.entity?.type === EntityType.PrimitiveEntity &&
+				pkDataType.entity.name === PrimitiveTypes.Number
+			) {
+				const num = Number(value);
+				return isNaN(num) ? null : num;
+			}
+		}
+	}
+	return value;
+}
+
+async function migrateAndCompactData(
+	dbName: string,
+	tablesToMigrate: {
+		tableName: string;
+		desiredColumnsMeta: { [colName: string]: any };
+		renames: { [old: string]: string };
+	}[]
+): Promise<void> {
+	return new Promise((resolve) => {
+		const request = indexedDB.open(dbName);
+		request.onerror = (event) => {
+			console.error(
+				'Failed to open DB for data migration:',
+				(event.target as any).error
+			);
+			resolve();
+		};
+		request.onsuccess = (event) => {
+			const db = request.result;
+			const tableNames = tablesToMigrate.map((t) => t.tableName);
+
+			// If any table names are not in db.objectStoreNames, filter them out to prevent transaction errors
+			const validTableNames = tableNames.filter((name) =>
+				db.objectStoreNames.contains(name)
+			);
+			if (validTableNames.length === 0) {
+				db.close();
+				resolve();
+				return;
+			}
+
+			try {
+				const transaction = db.transaction(
+					validTableNames,
+					'readwrite'
+				);
+
+				tablesToMigrate.forEach((tableInfo) => {
+					if (!db.objectStoreNames.contains(tableInfo.tableName)) {
+						return;
+					}
+					const store = transaction.objectStore(tableInfo.tableName);
+					const cursorRequest = store.openCursor();
+
+					cursorRequest.onsuccess = (e) => {
+						const cursor = (e.target as any).result;
+						if (cursor) {
+							const row = cursor.value;
+							let modified = false;
+
+							// 1. Process renames
+							Object.entries(tableInfo.renames).forEach(
+								([oldCol, newCol]) => {
+									if (row[oldCol] !== undefined) {
+										row[newCol] = row[oldCol];
+										delete row[oldCol];
+										modified = true;
+									}
+								}
+							);
+
+							// 2. Compact: delete any fields not in the desired columns list
+							Object.keys(row).forEach((key) => {
+								if (!tableInfo.desiredColumnsMeta[key]) {
+									delete row[key];
+									modified = true;
+								}
+							});
+
+							// 2.5 Type Casting (e.g. String to Number for foreign keys)
+							Object.entries(
+								tableInfo.desiredColumnsMeta
+							).forEach(([colName, colMeta]) => {
+								if (colMeta.dataType === 'number') {
+									if (typeof row[colName] === 'string') {
+										const parsed = Number(row[colName]);
+										if (!isNaN(parsed)) {
+											row[colName] = parsed;
+											modified = true;
+										} else if (row[colName] === '') {
+											row[colName] = null;
+											modified = true;
+										}
+									}
+								}
+							});
+
+							// 3. Drop rows that are incompatible with the new shape
+							let isCompatible = true;
+							Object.entries(
+								tableInfo.desiredColumnsMeta
+							).forEach(([colName, colMeta]) => {
+								if (
+									colMeta.notNull &&
+									(colMeta.default === undefined ||
+										colMeta.default === null)
+								) {
+									if (
+										row[colName] === undefined ||
+										row[colName] === null
+									) {
+										isCompatible = false;
+									}
+								}
+							});
+
+							if (!isCompatible) {
+								cursor.delete();
+							} else if (modified) {
+								cursor.update(row);
+							}
+							cursor.continue();
+						}
+					};
+				});
+
+				transaction.oncomplete = () => {
+					db.close();
+					resolve();
+				};
+				transaction.onerror = (e) => {
+					console.error(
+						'Transaction error in migrateAndCompactData:',
+						(e.target as any).error
+					);
+					db.close();
+					resolve();
+				};
+			} catch (err) {
+				console.error(
+					'Error during migrateAndCompactData transaction creation:',
+					err
+				);
+				db.close();
+				resolve();
+			}
+		};
+	});
+}
+
+type PrimitiveRawResults =
+	| number
+	| string
+	| boolean
+	| null
+	| Date
+	| (number | string | boolean | null | Date)[];
+
+type RawResults = PrimitiveRawResults | PrimitiveRawResults[] | RawResults[];
+
+// This entity puts the connection to a real local database and the entity that owns it under one object
+export class Database {
+	connection:
+		| (Connection & {
+				$sql: {
+					run: (sql: string) => Promise<any>;
+				};
+		  } & {
+				// Missing while not fully initialized
+				database?: IDataBase;
+		  })
+		| null = null;
+
+	entity: DefinitionEntityState;
+	tables: Table[] = [];
+
+	// Total number of rows in all tables
+	total: number = 0;
+
+	store: LocalRelationalDatabasesStore;
+
+	onGoingQueryCache: {
+		[query: string]: ISelectQueryResult;
+	} = {};
+
+	constructor(
+		entity: DefinitionEntityState,
+		store: LocalRelationalDatabasesStore
+	) {
+		this.store = store;
+		this.entity = entity;
+
+		this.processSelectQuery = this.processSelectQuery.bind(this);
+		this.init = this.init.bind(this);
+	}
+
+	async destroy() {
+		try {
+			// Clear local storage mappings for this database's tables
+			const attachedTableEntities: DefinitionEntityState[] =
+				this.store.persistedEntities.filter((persistedEntity) => {
+					const databaseEntity = getDatabaseEntity(persistedEntity);
+					return (
+						!!databaseEntity &&
+						databaseEntity?.id === this.entity?.id
+					);
+				});
+
+			attachedTableEntities.forEach((tableEntity) => {
+				const mappingKey = `elyx__local_db_column_mappings__${tableEntity.project.id}__${tableEntity.id}`;
+				try {
+					localStorage.removeItem(mappingKey);
+				} catch (e) {
+					// Ignore
+				}
+			});
+
+			// If the database is not initialized, it will throw an error
+			// But it might actually exist in storage
+			// So we need to catch the error, re-initialize the connection and drop the database
+			await this.connection.dropDb();
+		} catch (e) {
+			// Ignore the error
+			console.log('Error dropping database:', e);
+		}
+
+		await this.disconnect();
+
+		// Remove the database from the store
+		this.store.databases = this.store.databases.filter(
+			(db) => db.entity.id !== this.entity.id
+		);
+	}
+
+	static toDbName(entity: DefinitionEntityState): string {
+		const pascalName = toPascalCase(entity.name);
+		return `elyx__project--${entity.project.id}__${pascalName}__indexdb`;
+	}
+
+	get definition(): IDataBase {
+		const attachedTableEntities: DefinitionEntityState[] =
+			this.store.persistedEntities.filter((persistedEntity) => {
+				// Some persisted entities aren't directly extending the base built in abstract persisted entity
+				// But rather, extend another definition entity that eventually down the extension inheritance extends a base built in persisted entity
+				// For that reason, we first find the base persisted entity
+				const databaseEntity = getDatabaseEntity(persistedEntity);
+
+				return (
+					!!databaseEntity && databaseEntity?.id === this.entity?.id
+				);
+			});
+
+		const tables = attachedTableEntities.map(
+			persistedDefinitionEntityToDBTableConfig
+		);
+
+		const dbName = Database.toDbName(this.entity);
+
+		const dataBaseDef: IDataBase = {
+			name: dbName,
+			tables: tables.map((table) => table.definition)
+		};
+
+		return dataBaseDef;
+	}
+
+	async init(): Promise<Database> {
+		// Find the persisted entities that belong to this db
+		// Persisted entities have a property called 'database' that points to the db entity
+		const attachedTableEntities: DefinitionEntityState[] =
+			this.store.persistedEntities.filter((persistedEntity) => {
+				// Some persisted entities aren't directly extending the base built in abstract persisted entity
+				// But rather, extend another definition entity that eventually down the extension inheritance extends a base built in persisted entity
+				// For that reason, we first find the base persisted entity
+				const databaseEntity = getDatabaseEntity(persistedEntity);
+
+				return (
+					!!databaseEntity && databaseEntity?.id === this.entity?.id
+				);
+			});
+
+		// Initialize the db with one table for each attached entity
+		const tables = attachedTableEntities.map(
+			persistedDefinitionEntityToDBTableConfig
+		);
+
+		const tablesToMigrate: {
+			tableName: string;
+			desiredColumnsMeta: { [colName: string]: any };
+			renames: { [old: string]: string };
+		}[] = [];
+
+		tables.forEach((table) => {
+			const mappingKey = `elyx__local_db_column_mappings__${table.entity.project.id}__${table.entity.id}`;
+			let savedMappings: { [propertyId: string]: string } = {};
+			try {
+				const rawMappings = localStorage.getItem(mappingKey);
+				if (rawMappings) {
+					savedMappings = JSON.parse(rawMappings);
+				}
+			} catch (e) {
+				console.error(
+					'Failed to parse column mappings from localStorage:',
+					e
+				);
+			}
+
+			const currentProperties = getColumnProperties(table.entity);
+			const renames: { [oldCol: string]: string } = {};
+
+			currentProperties.forEach((prop) => {
+				const oldColumnName = savedMappings[prop.id];
+				const newColumnName =
+					prop.codeName ||
+					lowercaseFirstLetter(
+						toCamelCase(
+							resolveEntityName(prop, table.entity.project)
+						)
+					);
+
+				if (oldColumnName && oldColumnName !== newColumnName) {
+					renames[oldColumnName] = newColumnName;
+				}
+				savedMappings[prop.id] = newColumnName;
+			});
+
+			try {
+				localStorage.setItem(mappingKey, JSON.stringify(savedMappings));
+			} catch (e) {
+				console.error(
+					'Failed to save column mappings to localStorage:',
+					e
+				);
+			}
+
+			tablesToMigrate.push({
+				tableName: table.definition.name,
+				desiredColumnsMeta: table.definition.columns,
+				renames
+			});
+		});
+
+		const dbName = Database.toDbName(this.entity);
+
+		const existingDbDef = await describeExisting(dbName);
+
+		const sanitizedExistingDBDef = !!existingDbDef
+			? {
+					...existingDbDef,
+					tables:
+						existingDbDef?.tables.filter(
+							(table) => table.name !== 'JsStore_Meta'
+						) || []
+				}
+			: null;
+
+		const existingVersion = sanitizedExistingDBDef?.version || 1;
+
+		const tablesToRecreate: {
+			oldTableName: string;
+			newTableName: string;
+			oldPrimaryKey: string;
+			newPrimaryKey: string;
+			rows: any[];
+		}[] = [];
+
+		let connection = this.connection || (await initLocalDBConnection());
+
+		if (sanitizedExistingDBDef) {
+			for (const table of tables) {
+				const existingTable = sanitizedExistingDBDef.tables.find(
+					(t) => t.name === table.definition.name
+				);
+				if (existingTable) {
+					const desiredPrimaryKeyCol = Object.entries(
+						table.definition.columns
+					).find(([_, colMeta]) => colMeta.primaryKey);
+					const desiredPrimaryKeyName = desiredPrimaryKeyCol?.[0];
+
+					const existingPrimaryKeyCol = Object.entries(
+						existingTable.columns
+					).find(([_, colMeta]) => colMeta.primaryKey);
+					const existingPrimaryKeyName = existingPrimaryKeyCol?.[0];
+
+					if (
+						existingPrimaryKeyName &&
+						desiredPrimaryKeyName &&
+						existingPrimaryKeyName !== desiredPrimaryKeyName
+					) {
+						let rows: any[] = [];
+						try {
+							rows = await new Promise<any[]>(
+								(resolve, reject) => {
+									const request = indexedDB.open(dbName);
+									request.onsuccess = (event) => {
+										const db = (event.target as any).result;
+										try {
+											if (
+												!db.objectStoreNames.contains(
+													table.definition.name
+												)
+											) {
+												db.close();
+												resolve([]);
+												return;
+											}
+											const transaction = db.transaction(
+												table.definition.name,
+												'readonly'
+											);
+											const store =
+												transaction.objectStore(
+													table.definition.name
+												);
+											const getAllReq = store.getAll();
+											getAllReq.onsuccess = () => {
+												const result =
+													getAllReq.result || [];
+												db.close();
+												resolve(result);
+											};
+											getAllReq.onerror = () => {
+												db.close();
+												reject(getAllReq.error);
+											};
+										} catch (err) {
+											db.close();
+											reject(err);
+										}
+									};
+									request.onerror = (event) => {
+										reject((event.target as any).error);
+									};
+								}
+							);
+						} catch (e) {
+							console.error(
+								`Failed to fetch rows for recreating table ${table.definition.name}:`,
+								e
+							);
+						}
+
+						tablesToRecreate.push({
+							oldTableName: table.definition.name,
+							newTableName: table.definition.name,
+							oldPrimaryKey: existingPrimaryKeyName,
+							newPrimaryKey: desiredPrimaryKeyName,
+							rows
+						});
+					}
+				}
+			}
+		}
+
+		// The target definition is the one that we want to have
+		// We will populate it, from the difference between the existing definition and the target definition
+		const finalDef: IDataBase = {
+			name: dbName,
+			tables: [] as ITable[]
+		};
+
+		// If anything has changed, increment the version
+		let hasChanged: boolean = false;
+		let nextVersion = existingVersion;
+
+		const increaseVersion = () => {
+			if (!hasChanged) {
+				hasChanged = true;
+				nextVersion++;
+			}
+
+			return nextVersion;
+		};
+
+		const tablesToAdd: ITable[] = [];
+		const tablesToRemove: ITable[] = [];
+		const tablesToModify: ITable[] = [];
+
+		// Loop over the existing definition tables
+		sanitizedExistingDBDef?.tables?.forEach((table) => {
+			const desiredTable = tables.find(
+				(t) => t.definition.name === table.name
+			);
+
+			if (!desiredTable) {
+				increaseVersion();
+				tablesToRemove.push(table);
+			}
+		});
+
+		const columnsToDrop: { tableName: string; columnName: string }[] = [];
+
+		tables.forEach((table) => {
+			const existingTable = sanitizedExistingDBDef?.tables?.find(
+				(t) => t.name === table.definition.name
+			);
+			if (existingTable) {
+				Object.keys(existingTable.columns).forEach(
+					(existingColumnName) => {
+						if (!table.definition.columns[existingColumnName]) {
+							columnsToDrop.push({
+								tableName: table.definition.name,
+								columnName: existingColumnName
+							});
+						}
+					}
+				);
+			}
+		});
+
+		if (
+			tablesToRecreate.length > 0 ||
+			tablesToRemove.length > 0 ||
+			columnsToDrop.length > 0
+		) {
+			const deleteVersion = existingVersion + 1;
+			nextVersion = deleteVersion + 1;
+			hasChanged = true;
+
+			// Natively delete the object stores and indexes
+			await new Promise<void>((resolveDelete) => {
+				if (connection) {
+					connection.terminate();
+				}
+				const request = indexedDB.open(dbName, deleteVersion);
+				request.onupgradeneeded = (event) => {
+					const db = request.result;
+					const transaction = request.transaction;
+
+					tablesToRecreate.forEach((t) => {
+						if (db.objectStoreNames.contains(t.oldTableName)) {
+							db.deleteObjectStore(t.oldTableName);
+						}
+					});
+					tablesToRemove.forEach((t) => {
+						if (db.objectStoreNames.contains(t.name)) {
+							db.deleteObjectStore(t.name);
+						}
+					});
+
+					if (transaction) {
+						columnsToDrop.forEach((c) => {
+							if (db.objectStoreNames.contains(c.tableName)) {
+								const store = transaction.objectStore(
+									c.tableName
+								);
+								if (store.indexNames.contains(c.columnName)) {
+									store.deleteIndex(c.columnName);
+								}
+							}
+						});
+					}
+				};
+				request.onsuccess = (event) => {
+					const db = request.result;
+					db.close();
+					resolveDelete();
+				};
+				request.onerror = () => {
+					resolveDelete();
+				};
+				request.onblocked = () => {
+					console.warn(
+						'IndexedDB open blocked during table recreation'
+					);
+					resolveDelete();
+				};
+			});
+
+			// Re-initialize connection
+			connection = await initLocalDBConnection();
+		}
+
+		/*
+			Compare both definitions
+			Loop over the desired definition tables
+			For each table, check if all columns exist, if not, add the new column definition as 'alter -> add'
+			For each unrecognized column, add the column definition as 'alter -> drop'
+			For each colmn present in both, check if the data-type and other metadata matches, if not, add the new column definition as 'alter -> modify'
+		*/
+
+		// When a data-type changes, we need to migrate the data
+		// So we store here a list of migrations needed as a from -> to pair of property version instances
+		// The from is the last PropertyState version that had a data-type like the one in the database
+		// The to is the new PropertyState version that is being added to the table
+		const migrationRequests: {
+			from: PropertyState;
+			to: PropertyState;
+		}[] = [];
+
+		// Loop over the desired definition tables
+		tables.forEach((table) => {
+			const existingTable = sanitizedExistingDBDef.tables.find(
+				(t) => t.name === table.definition.name
+			);
+
+			const isRecreating = tablesToRecreate.some(
+				(t) => t.oldTableName === table.definition.name
+			);
+
+			if (!existingTable || isRecreating) {
+				increaseVersion();
+				tablesToAdd.push(table.definition);
+				finalDef.tables.push(table.definition);
+				return;
+			}
+
+			let finalTable: ITable = {
+				name: table.definition.name,
+				columns: table.definition.columns
+			};
+
+			// Loop over the desired definition columns
+			Object.entries(table.definition.columns).forEach(
+				([targetColumnName, targetColMeta]) => {
+					const columnEntries = Object.entries(existingTable.columns);
+
+					const result = columnEntries.find(
+						([cName, cMeta]) => cName === targetColumnName
+					);
+
+					const existingColumnName = result?.[0];
+					const existingColMeta = result?.[1];
+
+					if (!existingColumnName) {
+						increaseVersion();
+						tablesToModify.push(table.definition);
+						finalTable = {
+							...finalTable,
+							alter: {
+								...(finalTable.alter || {}),
+								[nextVersion]: {
+									...(finalTable.alter?.[nextVersion] || {}),
+									add: {
+										...(finalTable.alter?.[nextVersion]
+											?.add || {}),
+										[targetColumnName]: targetColMeta
+									}
+								}
+							}
+						};
+						return;
+					}
+
+					// Check if the data-type and other metadata matches
+					if (existingColMeta.dataType !== targetColMeta.dataType) {
+						increaseVersion();
+						tablesToModify.push(table.definition);
+						finalTable = {
+							...finalTable,
+							alter: {
+								...(finalTable.alter || {}),
+								[nextVersion]: {
+									...(finalTable.alter?.[nextVersion] || {}),
+									modify: {
+										...(finalTable.alter?.[nextVersion]
+											?.modify || {}),
+										[targetColumnName]: targetColMeta
+									}
+								}
+							}
+						};
+
+						// TODO: Here subscribe to 'migrationRequests'
+
+						return;
+					}
+				}
+			);
+
+			// Loop over the existing definition columns
+			Object.entries(existingTable.columns).forEach(
+				([existingColumnName, existingColMeta]) => {
+					const targetColMeta =
+						table.definition.columns[existingColumnName];
+
+					if (!targetColMeta) {
+						increaseVersion();
+						tablesToModify.push(table.definition);
+						finalTable = {
+							...finalTable,
+							alter: {
+								...(finalTable.alter || {}),
+								[nextVersion]: {
+									...(finalTable.alter?.[nextVersion] || {}),
+									drop: {
+										...(finalTable.alter?.[nextVersion]
+											?.drop || {}),
+										[existingColumnName]: null
+									}
+								}
+							}
+						};
+						return;
+					}
+				}
+			);
+
+			finalDef.tables.push(finalTable);
+		});
+
+		finalDef.version = nextVersion;
+
+		// If a database exists, it will not add the new tables, it will just initialize the database connection
+		const created = await initLocalIndexedDatabase(connection, finalDef);
+
+		this.connection = connection;
+
+		// Perform IndexedDB schema and data migration and compaction
+		await migrateAndCompactData(dbName, tablesToMigrate);
+
+		// Restore recreated tables data
+		if (tablesToRecreate.length > 0) {
+			for (const t of tablesToRecreate) {
+				if (t.rows.length > 0) {
+					const mappedRows = t.rows.map((row) => {
+						const newRow = { ...row };
+						if (row[t.oldPrimaryKey] !== undefined) {
+							newRow[t.newPrimaryKey] = row[t.oldPrimaryKey];
+							delete newRow[t.oldPrimaryKey];
+						}
+						return newRow;
+					});
+					try {
+						await connection.insert({
+							into: t.newTableName,
+							values: mappedRows
+						});
+					} catch (e) {
+						console.error(
+							`Failed to restore rows for table ${t.newTableName}:`,
+							e
+						);
+					}
+				}
+			}
+		}
+
+		// Init tables
+		await Promise.all(
+			tables.map(async (table) => {
+				const existingTableInstance = this.tables.find(
+					(t) => t.tableName === table.definition.name
+				);
+				const tableInstance =
+					existingTableInstance ||
+					new Table(table.definition.name, table.entity, this);
+
+				await tableInstance.init();
+
+				this.tables.push(tableInstance);
+			})
+		);
+
+		this.store.project.emit('local-databases-updated', this);
+
+		return this;
+	}
+
+	async disconnect(): Promise<void> {
+		await this.connection.terminate();
+		this.connection = null;
+	}
+
+	async describe(initialQuery: any): Promise<IDataBaseDetails> {
+		// @ts-ignore Because it is a protected property
+		const databaseStructureDef = this.connection.database;
+
+		let preselectedTableDef: ITable | null = null;
+		let preselectedTable: Table | null = null;
+		let preselectedTableEntity: DefinitionEntityState | null = null;
+
+		if (initialQuery.tableName) {
+			preselectedTableDef = databaseStructureDef.tables.find(
+				(table) => table.name === initialQuery.tableName
+			);
+
+			preselectedTable = this.tables.find(
+				(t) => t.tableName === initialQuery.tableName
+			);
+
+			preselectedTableEntity = preselectedTable?.entity;
+		}
+
+		if (!preselectedTableDef) {
+			return {
+				items: databaseStructureDef.tables.map((t) => {
+					const table = this.tables.find(
+						(ta) => ta.tableName === t.name
+					);
+
+					return table;
+				}),
+				data: null,
+				total: this.total
+			};
+		}
+
+		const rows: {
+			[columnName: string]: any;
+		}[] = initialQuery.tableName
+			? await this.connection.select({
+					from: initialQuery.tableName,
+					limit: initialQuery.limit
+				})
+			: [];
+
+		const initialColumns: searchStatementUtils.IColumnMapping[] = (
+			preselectedTable?.columns || []
+		).map((column) => ({
+			column: column,
+			as: column.columnName
+		}));
+
+		return {
+			items: databaseStructureDef.tables.map((tabl) => {
+				const table = this.tables.find(
+					(t) => t.tableName === tabl.name
+				);
+
+				return table;
+			}),
+			data: initialQuery.tableName
+				? {
+						tableName: preselectedTableDef.name,
+						entity: preselectedTableEntity,
+						columns: initialColumns,
+						rows: rows,
+						total: preselectedTable.total
+					}
+				: null,
+			total: this.total
+		};
+	}
+
+	// Given an entity id that represents a table in the database
+	// Return the table object
+	getTable(entityIdOrTableName: string): Table {
+		return this.tables.find(
+			(table) =>
+				table.entity.id === entityIdOrTableName ||
+				table.tableName === entityIdOrTableName
+		);
+	}
+
+	async checkForeignKeyConstraintsForUpdate(
+		tableName: string,
+		setValues: any
+	) {
+		const table = this.getTable(tableName);
+		if (!table) return;
+
+		for (const column of table.columns) {
+			const foreignKeyValue = setValues[column.columnName];
+			if (foreignKeyValue === undefined) {
+				continue; // Not being updated
+			}
+
+			const dataType = column.property?.dataType;
+			const fkInfo = resolveForeignKeyInfo(dataType);
+			if (fkInfo) {
+				const referencedEntity = fkInfo.entity;
+				const referencedDb =
+					this.store.getDatabaseForPersistedEntity(referencedEntity);
+				if (!referencedDb) continue;
+
+				const referencedTableName = toPascalCase(
+					resolveEntityName(
+						referencedEntity,
+						this.store.project.logic
+					)
+				);
+				const referencedTable =
+					referencedDb.getTable(referencedTableName);
+				if (!referencedTable) continue;
+
+				if (foreignKeyValue == null) {
+					continue;
+				}
+
+				// Find the primary key name of the referenced table
+				const referencedPrimaryKeyName = fkInfo.foreignKey.key;
+
+				// Query the referenced table
+				const referencedRows = await referencedDb.connection.select({
+					from: referencedTableName,
+					where: {
+						[referencedPrimaryKeyName]: foreignKeyValue
+					},
+					limit: 1
+				});
+
+				if (referencedRows.length === 0) {
+					throw new Error(
+						`SequelizeDatabaseError: Foreign key constraint failed: Referenced record in table "${referencedTableName}" does not exist`
+					);
+				}
+			}
+		}
+	}
+
+	async checkForeignKeyConstraintsForInsert(
+		tableName: string,
+		values: any[]
+	) {
+		for (const row of values) {
+			await this.checkForeignKeyConstraintsForUpdate(tableName, row);
+		}
+	}
+
+	async insert(query: IInsertQuery): Promise<any> {
+		const table = this.getTable(query.into);
+		if (table && query.values) {
+			query.values = query.values.map((row) => {
+				const sanitizedRow: any = { ...row };
+				table.columns.forEach((column) => {
+					const value = row[column.columnName];
+					if (value !== undefined) {
+						sanitizedRow[column.columnName] =
+							sanitizeValueForColumn(value, column);
+					}
+				});
+				return sanitizedRow;
+			});
+
+			await this.checkForeignKeyConstraintsForInsert(
+				query.into,
+				query.values
+			);
+		}
+
+		const result = await this.connection.insert(query);
+
+		// Update the total number of rows in the table
+		if (table) {
+			table.total += query.values.length;
+		}
+
+		this.store.project.emit('local-databases-updated', this);
+
+		return result;
+	}
+
+	async update(query: IUpdateQuery): Promise<any> {
+		const table = this.getTable(query.in);
+		if (table && query.set) {
+			const sanitizedSet: any = { ...query.set };
+			table.columns.forEach((column) => {
+				const value = query.set[column.columnName];
+				if (value !== undefined) {
+					sanitizedSet[column.columnName] = sanitizeValueForColumn(
+						value,
+						column
+					);
+				}
+			});
+			query.set = sanitizedSet;
+
+			await this.checkForeignKeyConstraintsForUpdate(query.in, query.set);
+		}
+
+		const result = await this.connection.update(query);
+
+		this.store.project.emit('local-databases-updated', this);
+
+		return result;
+	}
+
+	async remove(query: IRemoveQuery): Promise<any> {
+		// Find rows being targeted for deletion
+		const rowsToDelete = await this.connection.select({
+			from: query.from,
+			where: query.where
+		});
+
+		if (rowsToDelete.length > 0) {
+			const table = this.getTable(query.from);
+			const primaryKeyName =
+				table.columns.find((col) => col.primaryKey)?.columnName || 'id';
+			const primaryKeyValues = rowsToDelete
+				.map((row) => (row as any)[primaryKeyName])
+				.filter((val) => val != null);
+
+			if (primaryKeyValues.length > 0) {
+				// Iterate over all tables in this database
+				for (const otherTable of this.tables) {
+					for (const column of otherTable.columns) {
+						const dataType = column.property?.dataType;
+						if (
+							dataType?.entity?.type ===
+								EntityType.DefinitionEntity &&
+							dataType.entity.id === table.entity.id
+						) {
+							// This column references table.entity!
+							// Check if there are any rows in otherTable where this column holds one of primaryKeyValues
+							const referencingRows =
+								await this.connection.select({
+									from: otherTable.tableName,
+									where: {
+										[column.columnName]: {
+											in: primaryKeyValues
+										}
+									}
+								});
+
+							const otherTablePrimaryKeyName =
+								otherTable.columns.find((col) => col.primaryKey)
+									?.columnName || 'id';
+							const actualReferencingRows =
+								referencingRows.filter((row) => {
+									const rowId = (row as any)[
+										otherTablePrimaryKeyName
+									];
+									// If this referencing row is also among the ones being deleted, it's fine!
+									if (otherTable.tableName === query.from) {
+										return !primaryKeyValues.includes(
+											rowId
+										);
+									}
+									return true;
+								});
+
+							if (actualReferencingRows.length > 0) {
+								throw new Error(
+									`SequelizeForeignKeyConstraintError: update or delete on table "${query.from}" violates foreign key constraint on table "${otherTable.tableName}"`
+								);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		await this.connection.remove(query);
+
+		// Recalculate the total number of rows in the table
+		const table = this.getTable(query.from);
+
+		await table.updateTotal();
+
+		this.store.project.emit('local-databases-updated', this);
+	}
+
+	async clear(table: string): Promise<any> {
+		await this.connection.clear(table);
+
+		// Recalculate the total number of rows in the table
+		const tableInstance = this.getTable(table);
+
+		await tableInstance.updateTotal();
+
+		this.store.project.emit('local-databases-updated', this);
+	}
+
+	select(query: ISelectQuery): Promise<
+		{
+			[columnName: string]: any;
+		}[]
+	> {
+		return this.connection.select(query);
+	}
+
+	/*
+		Jsstore doesn't have feature parity with SQL
+		So we process the 'where' clause separately
+		This means, the first query is executed in jsstore without any 'where' clause filters
+		Then, we filter the results in memory
+
+		To achieve the filtering of the results according to the potentially complex and nested 'where' clause
+		We divide the 'where' clause into smaller parts, each representing a single 'where' condition
+		Then merge the results base on "and" and "or" conditions, where if a row passes all "and" conditions, it is included
+		And if a row passes any "or" condition, it is included
+	*/
+	async processFiltering(
+		selectStatement: SelectStmt,
+		rows: {
+			[columnName: string]: any;
+		}[]
+	): Promise<
+		{
+			[columnName: string]: any;
+		}[]
+	> {
+		const whereClause =
+			searchStatementUtils.getWhereClauseFromSelectStatement(
+				selectStatement
+			);
+
+		if (!whereClause) {
+			return rows;
+		}
+
+		return rows;
+	}
+
+	evaluateNode(
+		node: SearchNode,
+		dataSources: { source: DataSource; data: any }[] = []
+	): any {
+		if (!node) return null;
+
+		if (node.type === SearchStatementNodeType.LiteralValue) {
+			return (node as any).value;
+		}
+
+		if (node.type === SearchStatementNodeType.ColumnRef) {
+			const col = node as ColumnRef;
+			const ds = dataSources.find((d) => d.source?.as === col.parent?.as);
+			if (ds && ds.data) {
+				let ogColumnName = '';
+				if (col.source?.type === EntityType.Property) {
+					ogColumnName =
+						(col.source as PropertyState)?.codeName ||
+						lowercaseFirstLetter(
+							toCamelCase(
+								resolveEntityName(
+									col.source as PropertyState,
+									(col.source as PropertyState).project
+								)
+							)
+						);
+				} else if (
+					col.source?.type === SearchStatementNodeType.LiteralValue
+				) {
+					ogColumnName = (col.source as any).value?.toString() || '';
+				} else if (
+					col.source?.type === SearchStatementNodeType.ColumnRef
+				) {
+					ogColumnName = (col.source as ColumnRef).as;
+				} else {
+					ogColumnName = col.as;
+				}
+				return ds.data[ogColumnName];
+			}
+			return null;
+		}
+
+		if (node.type === SearchStatementNodeType.FunctionCall) {
+			const func = node as FunctionCall;
+			const args = func.arguments.map((arg) =>
+				this.evaluateNode(arg as any, dataSources)
+			);
+			const funcName = func.functionName?.toLowerCase();
+
+			switch (funcName) {
+				case 'upper':
+					return typeof args[0] === 'string'
+						? args[0].toUpperCase()
+						: args[0];
+				case 'lower':
+					return typeof args[0] === 'string'
+						? args[0].toLowerCase()
+						: args[0];
+				case 'length':
+					return typeof args[0] === 'string' ? args[0].length : 0;
+				case 'concat':
+					return args.map((a) => a ?? '').join('');
+				case 'coalesce':
+					return (
+						args.find((a) => a !== null && a !== undefined) ?? null
+					);
+				case 'round': {
+					const num = Number(args[0]);
+					const decimals =
+						args[1] !== undefined ? Number(args[1]) : 0;
+					if (isNaN(num)) return null;
+					const factor = Math.pow(10, decimals);
+					return Math.round(num * factor) / factor;
+				}
+				case 'now':
+					return new Date();
+				case 'json_build_object': {
+					const obj: any = {};
+					for (let i = 0; i < args.length; i += 2) {
+						if (args[i] !== undefined && args[i] !== null) {
+							obj[String(args[i])] = args[i + 1];
+						}
+					}
+					return obj;
+				}
+				case 'row_to_json':
+					return args[0];
+				default:
+					return null;
+			}
+		}
+		return null;
+	}
+
+	evaluateAggregateNode(
+		func: FunctionCall,
+		rows: any[],
+		statement: SearchStatementState
+	): any {
+		const funcName = func.functionName?.toLowerCase();
+		const args = func.arguments;
+
+		if (funcName === 'count') {
+			if (args[0]?.type === SearchStatementNodeType.AllColumnsSelector)
+				return rows.length;
+			let count = 0;
+			rows.forEach((row) => {
+				const dataSources = [
+					{ source: statement.from, data: row },
+					...statement.aggregations.map((a) => ({
+						source: a.dataSource,
+						data: row
+					}))
+				];
+				const val = this.evaluateNode(
+					args[0] as any,
+					dataSources as any
+				);
+				if (val !== null && val !== undefined) count++;
+			});
+			return count;
+		}
+
+		if (['sum', 'max', 'min', 'json_agg'].includes(funcName)) {
+			let sum = 0,
+				max: number | null = null,
+				min: number | null = null;
+			const arr: any[] = [];
+
+			rows.forEach((row) => {
+				const dataSources = [
+					{ source: statement.from, data: row },
+					...statement.aggregations.map((a) => ({
+						source: a.dataSource,
+						data: row
+					}))
+				];
+				const val = this.evaluateNode(
+					args[0] as any,
+					dataSources as any
+				);
+
+				if (
+					funcName === 'sum' &&
+					typeof val === 'number' &&
+					!isNaN(val)
+				)
+					sum += val;
+				if (funcName === 'max' && val !== null && val !== undefined)
+					max = max === null || val > max ? val : max;
+				if (funcName === 'min' && val !== null && val !== undefined)
+					min = min === null || val < min ? val : min;
+				if (funcName === 'json_agg') arr.push(val);
+			});
+
+			if (funcName === 'sum') return sum;
+			if (funcName === 'max') return max;
+			if (funcName === 'min') return min;
+			if (funcName === 'json_agg') return arr;
+		}
+		return null;
+	}
+
+	checkCondition(
+		condition: WhereStatement,
+		dataSources: {
+			source: DataSource;
+			data: {
+				[columnName: string]: RawResults;
+			};
+		}[]
+	): boolean {
+		if (!condition?.isValid) {
+			return true;
+		}
+
+		if (condition.operator && condition.left && condition.right) {
+			let leftValue = this.evaluateNode(condition.left, dataSources);
+			let rightValue = this.evaluateNode(condition.right, dataSources);
+
+			if (leftValue === undefined) {
+				leftValue = null;
+			}
+			if (rightValue === undefined) {
+				rightValue = null;
+			}
+
+			switch (condition.operator) {
+				case WhereStatementOperator.Equal: {
+					return areValuesEqual(leftValue, rightValue);
+				}
+				case WhereStatementOperator.NotEqual: {
+					return !areValuesEqual(leftValue, rightValue);
+				}
+				case WhereStatementOperator.Like: {
+					if (leftValue === null || rightValue === null) {
+						return false;
+					}
+					const regex = new RegExp(
+						`^${rightValue.toString().replace(/%/g, '.*').replace(/_/g, '.')}$`
+					);
+					return regex.test(leftValue.toString());
+				}
+				case WhereStatementOperator.NotLike: {
+					if (leftValue === null || rightValue === null) {
+						return false;
+					}
+					const regex = new RegExp(
+						`^${rightValue.toString().replace(/%/g, '.*').replace(/_/g, '.')}$`
+					);
+					return !regex.test(leftValue.toString());
+				}
+				case WhereStatementOperator.In: {
+					if (!Array.isArray(rightValue))
+						throw new Error(
+							'Right value of "IN" operator must be an array'
+						);
+					return rightValue.some((val) =>
+						areValuesEqual(leftValue, val)
+					);
+				}
+				case WhereStatementOperator.Between: {
+					if (!Array.isArray(rightValue) || rightValue.length !== 2)
+						throw new Error(
+							'Right value of "BETWEEN" operator must be an array of two elements'
+						);
+					if (
+						leftValue === null ||
+						rightValue[0] === null ||
+						rightValue[1] === null
+					) {
+						return false;
+					}
+					const [l, r0] = coerceToComparable(
+						leftValue,
+						rightValue[0]
+					);
+					const [, r1] = coerceToComparable(l, rightValue[1]);
+					return l >= r0 && l <= r1;
+				}
+				case WhereStatementOperator.BiggerThan: {
+					if (leftValue === null || rightValue === null) {
+						return false;
+					}
+					const [l, r] = coerceToComparable(leftValue, rightValue);
+					return l > r;
+				}
+				case WhereStatementOperator.SmallerThan: {
+					if (leftValue === null || rightValue === null) {
+						return false;
+					}
+					const [l, r] = coerceToComparable(leftValue, rightValue);
+					return l < r;
+				}
+				case WhereStatementOperator.BiggerThanOrEqualTo: {
+					if (leftValue === null || rightValue === null) {
+						return false;
+					}
+					const [l, r] = coerceToComparable(leftValue, rightValue);
+					return l >= r;
+				}
+				case WhereStatementOperator.SmallerThanOrEqualTo: {
+					if (leftValue === null || rightValue === null) {
+						return false;
+					}
+					const [l, r] = coerceToComparable(leftValue, rightValue);
+					return l <= r;
+				}
+			}
+		}
+
+		let andGroupMatches = true;
+
+		if (!!condition.and.length) {
+			andGroupMatches = condition.and.every((andCondition) =>
+				this.checkCondition(andCondition, dataSources)
+			);
+		}
+
+		let orGroupMatches = true;
+
+		if (!!condition.or.length) {
+			orGroupMatches = condition.or.some((orCondition) =>
+				this.checkCondition(orCondition, dataSources)
+			);
+		}
+
+		return andGroupMatches && orGroupMatches;
+	}
+
+	async applyJoinResults(
+		statement: SearchStatementState,
+		mainResults: {
+			[columnName: string]: RawResults;
+		}[],
+		joins: {
+			aggregation: AggregationStatement;
+			results: {
+				[columnName: string]: RawResults;
+			}[];
+		}[]
+	): Promise<
+		{
+			[columnName: string]: RawResults;
+		}[]
+	> {
+		let joinedResults = mainResults;
+
+		joinedResults = joins.reduce((acc, join) => {
+			const newAcc = [...acc];
+
+			if (join.aggregation.joinType === AggregationStatementType.Inner) {
+				// Inner join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				newAcc.forEach((mainRow) => {
+					join.results.forEach((joinRow) => {
+						// Check if the join condition is met
+						// If it is, merge the results
+						// If not, ignore the join result
+						if (
+							this.checkCondition(join.aggregation.on, [
+								{
+									source: statement.from,
+									data: mainRow
+								},
+								{
+									source: join.aggregation.dataSource,
+									data: joinRow
+								}
+							])
+						) {
+							newAcc.push({ ...mainRow, ...joinRow });
+						}
+					});
+				});
+			} else if (
+				join.aggregation.joinType === AggregationStatementType.Left
+			) {
+				// Left join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				newAcc.forEach((mainRow) => {
+					let matchFound = false;
+
+					join.results.forEach((joinRow) => {
+						// Check if the join condition is met
+						// If it is, merge the results
+						// If not, ignore the join result
+						if (
+							this.checkCondition(join.aggregation.on, [
+								{
+									source: statement.from,
+									data: mainRow
+								},
+								{
+									source: join.aggregation.dataSource,
+									data: joinRow
+								}
+							])
+						) {
+							matchFound = true;
+							newAcc.push({ ...mainRow, ...joinRow });
+						}
+					});
+
+					if (!matchFound) {
+						const joinColumns = Object.keys(
+							join.results[0] || {}
+						).reduce(
+							(a, key) => {
+								a[key] = null;
+								return a;
+							},
+							{} as {
+								[columnName: string]:
+									| number
+									| string
+									| boolean
+									| null
+									| Date;
+							}
+						);
+
+						newAcc.push({ ...mainRow, ...joinColumns });
+					}
+				});
+			} else if (
+				join.aggregation.joinType === AggregationStatementType.Right
+			) {
+				// Right join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				join.results.forEach((joinRow) => {
+					let matchFound = false;
+					// Check if the join condition is met
+					// If it is, merge the results
+					// If not, ignore the join result
+					newAcc.forEach((mainRow) => {
+						if (
+							this.checkCondition(join.aggregation.on, [
+								{
+									source: statement.from,
+									data: mainRow
+								},
+								{
+									source: join.aggregation.dataSource,
+									data: joinRow
+								}
+							])
+						) {
+							matchFound = true;
+							newAcc.push({ ...mainRow, ...joinRow });
+						}
+					});
+
+					if (!matchFound) {
+						const mainColumns = Object.keys(newAcc[0] || {}).reduce(
+							(a, key) => {
+								a[key] = null;
+								return a;
+							},
+							{} as {
+								[columnName: string]:
+									| number
+									| string
+									| boolean
+									| null
+									| Date;
+							}
+						);
+
+						newAcc.push({ ...mainColumns, ...joinRow });
+					}
+				});
+			} else if (
+				join.aggregation.joinType === AggregationStatementType.Full
+			) {
+				// Full join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				const matchedRows = new Set();
+
+				newAcc.forEach((mainRow) => {
+					let matchFound = false;
+
+					join.results.forEach((joinRow) => {
+						if (
+							this.checkCondition(join.aggregation.on, [
+								{
+									source: statement.from,
+									data: mainRow
+								},
+								{
+									source: join.aggregation.dataSource,
+									data: joinRow
+								}
+							])
+						) {
+							matchFound = true;
+							newAcc.push({ ...mainRow, ...joinRow });
+							matchedRows.add(joinRow);
+						}
+					});
+
+					if (!matchFound) {
+						const joinColumns = Object.keys(
+							join.results[0] || {}
+						).reduce(
+							(a, key) => {
+								a[key] = null;
+								return a;
+							},
+							{} as {
+								[columnName: string]:
+									| number
+									| string
+									| boolean
+									| null
+									| Date;
+							}
+						);
+
+						newAcc.push({ ...mainRow, ...joinColumns });
+					}
+				});
+
+				join.results.forEach((joinRow) => {
+					if (!matchedRows.has(joinRow)) {
+						const mainColumns = Object.keys(newAcc[0] || {}).reduce(
+							(a, key) => {
+								a[key] = null;
+								return a;
+							},
+							{} as {
+								[columnName: string]:
+									| number
+									| string
+									| boolean
+									| null
+									| Date;
+							}
+						);
+
+						newAcc.push({ ...mainColumns, ...joinRow });
+					}
+				});
+			} else if (
+				join.aggregation.joinType === AggregationStatementType.Cross
+			) {
+				// Cross join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				newAcc.forEach((mainRow) => {
+					join.results.forEach((joinRow) => {
+						// Check if the join condition is met
+						// If it is, merge the results
+						// If not, ignore the join result
+						newAcc.push({ ...mainRow, ...joinRow });
+					});
+				});
+			} else if (
+				join.aggregation.joinType === AggregationStatementType.Self
+			) {
+				// Self join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				newAcc.forEach((mainRow) => {
+					join.results.forEach((joinRow) => {
+						// Check if the join condition is met
+						// If it is, merge the results
+						// If not, ignore the join result
+						if (
+							this.checkCondition(join.aggregation.on, [
+								{
+									source: statement.from,
+									data: mainRow
+								},
+								{
+									source: join.aggregation.dataSource,
+									data: joinRow
+								}
+							])
+						) {
+							newAcc.push({ ...mainRow, ...joinRow });
+						}
+					});
+				});
+			} else if (
+				join.aggregation.joinType === AggregationStatementType.Natural
+			) {
+				// Get the keys that are common to both mainArray and joinArray rows
+				const commonKeys =
+					newAcc.length && join.results.length
+						? Object.keys(newAcc[0]).filter(
+								(key) => key in join.results[0]
+							)
+						: [];
+
+				// Check if two rows have matching values for all common keys
+				function hasMatchingCommonKeys(
+					row1: {
+						[columnName: string]: RawResults;
+					},
+					row2: {
+						[columnName: string]: RawResults;
+					}
+				) {
+					return commonKeys.every((key) => row1[key] === row2[key]);
+				}
+
+				// Natural join
+				// Loop over each row in the main results
+				// And join the results from the join results
+				// If the join condition is met
+				newAcc.forEach((mainRow) => {
+					join.results.forEach((joinRow) => {
+						// Check if the join condition is met
+						// If it is, merge the results
+						// If not, ignore the join result
+						if (hasMatchingCommonKeys(mainRow, joinRow)) {
+							newAcc.push({ ...mainRow, ...joinRow });
+						}
+					});
+				});
+			}
+
+			return newAcc;
+		}, joinedResults);
+
+		return joinedResults;
+	}
+
+	async applyWhereToResults(
+		statement: SearchStatementState,
+		results: {
+			[columnName: string]: RawResults;
+		}[]
+	): Promise<
+		{
+			[columnName: string]: RawResults;
+		}[]
+	> {
+		const whereClause = statement.where;
+
+		if (!whereClause) {
+			return results;
+		}
+
+		const filteredResults = results.filter((result) => {
+			const allSources = [
+				{
+					source: statement.from,
+					data: result
+				},
+				...statement.aggregations.map((aggregation) => ({
+					source: aggregation.dataSource,
+					data: result
+				}))
+			];
+
+			return this.checkCondition(whereClause, allSources);
+		});
+
+		return filteredResults;
+	}
+
+	mapResults(
+		statement: SearchStatementState,
+		rows: { [columnName: string]: RawResults }[]
+	): { [columnName: string]: RawResults }[] {
+		// 1. Check for aggregates (Giant Bucket Rule)
+		const hasAggregates = statement.validSelections.some(
+			(selection) =>
+				selection.type === SearchStatementNodeType.FunctionCall &&
+				(selection as FunctionCall).hasFunctionOfCategory(
+					SQLFunctionCategory.Aggregate
+				)
+		);
+
+		if (hasAggregates) {
+			const mappedResult: any = {};
+			statement.validSelections.forEach((selection) => {
+				// 1. Guard against AllColumnsSelector (it doesn't have an .as property)
+				if (
+					selection.type ===
+					SearchStatementNodeType.AllColumnsSelector
+				)
+					return;
+
+				if (selection.type === SearchStatementNodeType.FunctionCall) {
+					// 2. Cast to FunctionCall
+					mappedResult[(selection as FunctionCall).as] =
+						this.evaluateAggregateNode(
+							selection as FunctionCall,
+							rows,
+							statement
+						);
+				} else {
+					// 3. Cast to ColumnRef
+					mappedResult[(selection as ColumnRef).as] =
+						rows.length > 0
+							? this.evaluateNode(selection, [
+									{ source: statement.from, data: rows[0] }
+								])
+							: null;
+				}
+			});
+			return [mappedResult]; // Return exactly 1 row containing the aggregations
+		}
+
+		// 2. Standard Scalar Mapping
+		const mappedResults = rows.map((result) => {
+			const mappedResult: any = {};
+			const dataSources = [
+				{ source: statement.from, data: result },
+				...statement.aggregations.map((a) => ({
+					source: a.dataSource,
+					data: result
+				}))
+			];
+
+			const selectAll = statement.validSelections.find(
+				(selection) =>
+					selection.type ===
+					SearchStatementNodeType.AllColumnsSelector
+			);
+
+			if (selectAll) {
+				statement.columns.forEach((columnRef) => {
+					mappedResult[columnRef.as] = this.evaluateNode(
+						columnRef,
+						dataSources
+					);
+				});
+				return mappedResult;
+			}
+
+			statement.validSelections.forEach((selection) => {
+				if (!selection.isValid) return;
+
+				// 1. Tell TypeScript to skip AllColumnsSelector here too
+				if (
+					selection.type ===
+					SearchStatementNodeType.AllColumnsSelector
+				)
+					return;
+
+				// 2. Safely cast to access the .as property
+				const selectionWithAlias = selection as
+					| ColumnRef
+					| FunctionCall;
+
+				// Evaluate the node (Scalar Function or ColumnRef) directly from the row context!
+				mappedResult[selectionWithAlias.as] = this.evaluateNode(
+					selection,
+					dataSources
+				);
+			});
+
+			return mappedResult;
+		});
+
+		return mappedResults;
+	}
+
+	selectionsToColumns(statement: SearchStatementState): ColumnRef[] {
+		const selectAll = statement.validSelections.find(
+			(selection) =>
+				selection.type === SearchStatementNodeType.AllColumnsSelector
+		);
+
+		if (selectAll) {
+			const allColumns = statement.columns;
+
+			return allColumns;
+		}
+
+		return statement.columns;
+	}
+
+	// This function orders the rows
+	// Please note: we use jsstore for sorting simply because it has the logic built in
+	// But we don't use it as a normal select from the database, we pass it the rows we already have
+	async applySort(
+		statement: SearchStatementState,
+		rows: {
+			[columnName: string]: RawResults;
+		}[]
+	): Promise<
+		{
+			[columnName: string]: RawResults;
+		}[]
+	> {
+		const sorts = statement.validSortings;
+
+		if (!sorts.length) {
+			return rows;
+		}
+
+		const jsStoreSorts: IOrderQuery[] = sorts.map((sort) => {
+			const column = sort.column;
+
+			const jsStoreSort: IOrderQuery = {
+				by: column.as,
+				type:
+					sort.direction === SortStatementDirection.Ascending
+						? 'asc'
+						: 'desc'
+			};
+
+			return jsStoreSort;
+		});
+
+		// @ts-ignore It asks for properties that it doesn't need, like "meta.primaryKey"
+		const sortedRows = await this.connection.select({
+			store: rows,
+			order: jsStoreSorts
+		});
+
+		return sortedRows as {
+			[columnName: string]: RawResults;
+		}[];
+	}
+
+	applyLimitAndOffset(
+		statement: SearchStatementState,
+		rows: {
+			[columnName: string]: RawResults;
+		}[]
+	): {
+		[columnName: string]: RawResults;
+	}[] {
+		let offsetResults = rows;
+
+		if (
+			!!statement.offset &&
+			statement.offset.type === SearchStatementNodeType.LiteralValue &&
+			typeof statement.offset.value === 'number'
+		) {
+			const offset = statement.offset.value;
+
+			offsetResults = rows.slice(offset);
+		}
+
+		if (
+			!!statement.limit &&
+			statement.limit.type === SearchStatementNodeType.LiteralValue &&
+			typeof statement.limit.value === 'number'
+		) {
+			const limit = statement.limit.value;
+
+			offsetResults = offsetResults.slice(0, limit);
+		}
+
+		return offsetResults;
+	}
+
+	async executeSearchStatementAsQuery(
+		statement: SearchStatementState
+	): Promise<ISelectQueryResultV2 | null> {
+		if (!statement) {
+			return null;
+		}
+
+		if (!statement.from) {
+			// Check for literal values
+			let row: {
+				[columnName: string]: RawResults;
+			} = {};
+
+			statement.validSelectedColumns.forEach((column) => {
+				row[column.as] = column.literalValue?.flattenRawValue();
+			});
+
+			const literalSelectionResult: ISelectQueryResultV2 = {
+				columns: statement.validSelectedColumns,
+				rows: [row],
+				tableName: null,
+				entity: null,
+				total: 1
+			};
+
+			return literalSelectionResult;
+		}
+
+		let mainResults: {
+			[columnName: string]: RawResults;
+		}[] = [];
+
+		let mainEntity: DefinitionEntityState | null = null;
+
+		if (
+			statement.from.source.type ===
+			SearchStatementNodeType.NestedSearchStatement
+		) {
+			const subQueryResult = await this.executeSearchStatementAsQuery(
+				// @ts-ignore
+				statement.from.source.statement
+			);
+
+			mainResults = subQueryResult.rows;
+		} else if (statement.from.source.type === EntityType.DefinitionEntity) {
+			const mainSourceResults = await this.select({
+				from: toPascalCase(statement.from.source.name)
+			});
+
+			mainResults = mainSourceResults;
+			mainEntity = statement.from.source;
+		} else if (
+			statement.from.sourceType === DataSourceType.Function &&
+			statement.from.functionCall
+		) {
+			// --- NEW: EMULATE GENERATE_SERIES AND UNNEST ---
+			const func = statement.from.functionCall;
+			const funcName = func.functionName.toLowerCase();
+			if (funcName === 'generate_series') {
+				const start = Number(
+					this.evaluateNode(func.arguments[0] as any, [])
+				);
+				const stop = Number(
+					this.evaluateNode(func.arguments[1] as any, [])
+				);
+				const step = func.arguments[2]
+					? Number(this.evaluateNode(func.arguments[2] as any, []))
+					: 1;
+				for (let i = start; i <= stop; i += step) {
+					mainResults.push({ [statement.from.as]: i });
+				}
+			} else if (funcName === 'unnest') {
+				const arr = this.evaluateNode(func.arguments[0] as any, []);
+				if (Array.isArray(arr)) {
+					mainResults = arr.map((item) => ({
+						[statement.from.as]: item
+					}));
+				}
+			}
+		}
+
+		const aggregationResults: {
+			aggregation: AggregationStatement;
+			results: {
+				[columnName: string]: number | string | boolean | null | Date;
+			}[];
+		}[] = !!statement.from
+			? await Promise.all(
+					statement.aggregations.map(async (aggregation) => {
+						if (
+							aggregation.dataSource?.source?.type ===
+							SearchStatementNodeType.NestedSearchStatement
+						) {
+							const results =
+								await this.executeSearchStatementAsQuery(
+									// @ts-ignore
+									aggregation.dataSource?.source?.statement
+								);
+
+							return {
+								aggregation,
+								results:
+									(results?.rows as {
+										[columnName: string]:
+											| number
+											| string
+											| boolean
+											| null
+											| Date;
+									}[]) || []
+							};
+						} else if (
+							aggregation.dataSource?.source?.type ===
+							EntityType.DefinitionEntity
+						) {
+							const results = await this.select({
+								from: toPascalCase(
+									aggregation.dataSource?.source?.name
+								)
+							});
+
+							return {
+								aggregation,
+								results: results as {
+									[columnName: string]:
+										| number
+										| string
+										| boolean
+										| null
+										| Date;
+								}[]
+							};
+						}
+
+						return {
+							aggregation,
+							results: []
+						};
+					})
+				)
+			: [];
+
+		const joinedResults = await this.applyJoinResults(
+			statement,
+			mainResults,
+			aggregationResults
+		);
+
+		const filteredResults = !!statement.from
+			? await this.applyWhereToResults(statement, joinedResults)
+			: joinedResults;
+
+		const mappedResults = this.mapResults(statement, filteredResults);
+
+		// Check if this is a pure table or there are aggregations or aliases
+		if (!statement.isUntouchedEntity) {
+			mainEntity = null;
+		}
+
+		const sortedResults = await this.applySort(statement, mappedResults);
+
+		// Apply limit and offset
+		const offsetResults = this.applyLimitAndOffset(
+			statement,
+			sortedResults
+		);
+
+		const result = {
+			columns: statement.validSelectedColumns,
+			rows: offsetResults,
+			tableName: !!mainEntity ? toPascalCase(mainEntity.name) : null,
+			entity: mainEntity,
+			total: offsetResults.length
+		};
+
+		return result;
+	}
+
+	async runStatement(
+		statement: SearchStatementState,
+		inputs: IDynamicValue[] = []
+	): Promise<ISelectQueryResultV2 | null> {
+		// console.log('[runStatement] Running statement: ', statement);
+		console.log(
+			`[runStatement] Inputs:\n   ${inputs
+				.map(
+					(d) =>
+						`${d.valueOwner?.type} (${d.valueOwner?.id}) "${resolveEntityName(d.valueOwner as any, this.store.project?.logic)}": ${JSON.stringify(d.value?.value, null, 2)}`
+				)
+				.join('\n   ')}`
+		);
+
+		if (!statement) {
+			return null;
+		}
+
+		const queryString = searchStatementUtils.sanitizeQuery(
+			statement.toQuery()
+		);
+
+		if (!queryString) {
+			return null;
+		}
+
+		let workingStatement = statement;
+
+		if (!!inputs?.length) {
+			const resolvedInputs = inputs.map((i) => {
+				if (i.valueOwner?.type === EntityType.ValueDescriptor) {
+					// Exchange the value-descriptor for its input-map counterpart
+					const parentInputs = ((i.valueOwner?.parent as SearchState)
+						?.inputs || []) as InputMapState[];
+
+					const foundInputMap = parentInputs.find(
+						(p) => p.declaration?.id === i.valueOwner?.id
+					);
+
+					return {
+						...i,
+						valueOwner: foundInputMap
+					};
+				}
+
+				return i;
+			});
+
+			const query = this.resolveRawInterpolationValues(
+				queryString,
+				resolvedInputs
+			);
+
+			console.log('Query:\n', query);
+
+			const sanitizedAST = SQLASTLib.parse(query, {
+				dialect: 'sqlite',
+				// These are optional:
+				includeSpaces: true // Adds spaces/tabs
+				// includeNewlines: true, // Adds newlines
+				// includeComments: true, // Adds comments
+				// includeRange: true, // Adds source code location data
+			});
+
+			const newStatementConfig =
+				searchStatementUtils.hydrateSearchStatementState(
+					sanitizedAST,
+					this.store.project.logic
+				);
+			workingStatement = newStatementConfig.state;
+		}
+
+		const result =
+			await this.executeSearchStatementAsQuery(workingStatement);
+
+		this.onGoingQueryCache = {};
+
+		return result;
+	}
+
+	async processSelectQuery(
+		selectStatement: SelectStmt
+	): Promise<ISelectQueryResult> {
+		if (!selectStatement) {
+			return null;
+		}
+
+		// @ts-ignore
+		if (this.onGoingQueryCache[selectStatement.id]) {
+			// @ts-ignore
+			return this.onGoingQueryCache[selectStatement.id];
+		}
+
+		let queryBase!:
+			| {
+					store: {
+						[key: string]: number | string | boolean | null | Date;
+					}[];
+					meta: {
+						primaryKey: string;
+					};
+			  }
+			| {
+					from: string;
+			  };
+
+		const mainSource =
+			searchStatementUtils.getMainSourceFromSelectStatement(
+				selectStatement
+			);
+		const selectClause =
+			searchStatementUtils.getSelectClauseFromSelectStatement(
+				selectStatement
+			);
+		const ownTableMappings: searchStatementUtils.IShallowColumnMapping[] =
+			searchStatementUtils.fromSelectClauseColumnsToColumnMappings(
+				selectClause,
+				(mainSource as any)?.name || ''
+				// (mainSource as any).name === 'Product'
+			);
+
+		const otherNewMappingsInTopSelect: searchStatementUtils.IShallowColumnMapping[] =
+			searchStatementUtils
+				.fromSelectClauseColumnsToColumnMappings(selectClause)
+				.filter(
+					(mapping) =>
+						!ownTableMappings.find(
+							(ownMapping) => ownMapping.from === mapping.from
+						)
+				);
+
+		let ownColumns: searchStatementUtils.IColumnMapping[] = [];
+		let mainEntity: DefinitionEntityState = null;
+
+		if (mainSource?.type === 'table') {
+			queryBase = {
+				from: mainSource.name
+			};
+
+			const table = this.getTable(mainSource.name);
+
+			mainEntity = table.entity;
+
+			ownColumns = table.columns.map((column) => {
+				const mapping = ownTableMappings.find(
+					(mapping) => mapping.from === column.columnName
+				);
+
+				return {
+					column: column,
+					as: mapping?.to || column.columnName
+				};
+			});
+		} else if (mainSource?.type === 'query' && !!mainSource.subquery) {
+			// Execute the 'from' subquery and get the result
+			const subQueryResult = await this.processSelectQuery(
+				mainSource.subquery
+			);
+			mainEntity = subQueryResult.entity;
+
+			queryBase = {
+				store: subQueryResult.rows,
+				meta: {
+					primaryKey: subQueryResult.columns.find(
+						(column) => column.column.primaryKey
+					).column.columnName
+				}
+			};
+
+			ownColumns = subQueryResult.columns.map((column) => {
+				const mapping = ownTableMappings.find(
+					(mapping) => mapping.from === column.as
+				);
+
+				return {
+					column: column.column,
+					as: mapping?.to || column.as
+				};
+			});
+		} else {
+			// Not supported
+			return {
+				columns: [],
+				rows: [],
+				tableName: null,
+				entity: null,
+				total: 0
+			};
+		}
+
+		let selectQuery: ISelectQuery = queryBase as ISelectQuery;
+
+		const offsetClause: LimitClause | null =
+			searchStatementUtils.getLimitClauseFromSelectStatement(
+				selectStatement
+			);
+
+		const rawOffset: number =
+			searchStatementUtils.getRawOffetFromLimitClause(
+				offsetClause
+			) as number;
+		const rawLimit: number | null =
+			searchStatementUtils.getRawLimitFromLimitClause(offsetClause) as
+				| number
+				| null;
+
+		const orderByClause =
+			searchStatementUtils.getOrderByClauseFromSelectStatement(
+				selectStatement
+			);
+
+		const joinClauses = await getJoinClausesFromSelectStatement(
+			selectStatement,
+			{
+				onNestedSelect: this.processSelectQuery,
+				onDescribeTable: async (tableName) => this.getTable(tableName)
+			}
+		);
+
+		if (rawLimit !== null) {
+			selectQuery.limit = rawLimit;
+		}
+
+		if (rawOffset) {
+			selectQuery.skip = rawOffset;
+		}
+
+		if (orderByClause) {
+			selectQuery.order = await fromOrderByClauseToJsStore(
+				orderByClause,
+				selectStatement,
+				{
+					onNestedSelect: this.processSelectQuery,
+					onDescribeTable: async (tableName) =>
+						this.getTable(tableName)
+				}
+			);
+		}
+
+		if (!!joinClauses.joins.length) {
+			selectQuery.join = joinClauses.joins;
+		}
+
+		const allSelectedColumnNames =
+			getAllSelectedColumnNamesFromSelectClause(selectClause);
+
+		const builtInPrimaryKeyPropertyId =
+			BUILT_IN_BASE_ENTITY_IDS[EntityType.BuiltInBaseEntity][
+				BaseEntityNames.PERSISTED_ENTITY
+			].properties.primaryKey.id;
+
+		let primaryKeyName = mainEntity.properties.find(
+			(property) =>
+				property.id === builtInPrimaryKeyPropertyId ||
+				property.implements.find(
+					(impl) => impl.id === builtInPrimaryKeyPropertyId
+				)
+		)?.name;
+
+		const allColumns: searchStatementUtils.IColumnMapping[] = [
+			...ownColumns,
+			...joinClauses.columnMappings
+			// Filter out duplicates
+		].filter((column, index, self) => {
+			return self.findIndex((c) => c.as === column.as) === index;
+		});
+
+		// We need to filter and rename any columns that have changed or aren't selected in t he querys
+		const resultingQueryColumns: searchStatementUtils.IColumnMapping[] =
+			allColumns.reduce((acc, columnMap) => {
+				const alreadyExists = acc.find((c) => c.as === columnMap.as);
+
+				if (alreadyExists) {
+					return acc;
+				}
+
+				const newlyMapped = otherNewMappingsInTopSelect.find(
+					(mapping) => mapping.from === columnMap.as
+				);
+
+				columnMap.as = newlyMapped?.to || columnMap.as;
+
+				const selected =
+					allSelectedColumnNames.includes(
+						columnMap.column.columnName
+					) || allSelectedColumnNames.includes(columnMap?.as);
+
+				if (columnMap?.column.columnName === primaryKeyName) {
+					primaryKeyName = columnMap.as;
+				} else if (!primaryKeyName && columnMap.column.primaryKey) {
+					primaryKeyName = columnMap.as;
+				}
+
+				if (selected) {
+					return [...acc, columnMap];
+				} else {
+					return acc;
+				}
+			}, [] as searchStatementUtils.IColumnMapping[]);
+
+		const whereClause =
+			searchStatementUtils.getWhereClauseFromSelectStatement(
+				selectStatement
+			);
+
+		if (whereClause) {
+			const resolvedWhereQuery = fromWhereClauseToJsStoreWhereObject(
+				whereClause,
+				allColumns
+			);
+
+			if (resolvedWhereQuery && Object.keys(resolvedWhereQuery).length) {
+				selectQuery.where = resolvedWhereQuery;
+			}
+		}
+
+		const rows: {
+			[columnName: string]: any;
+		}[] = await this.connection.select(selectQuery);
+
+		const filteredRows = await this.processFiltering(selectStatement, rows);
+
+		const count = filteredRows.length;
+
+		const mappedRows = filteredRows.map((row) => {
+			const newRow: { [columnName: string]: any } = {
+				...row
+			};
+
+			Object.keys(row).forEach((columnName) => {
+				const columnMapping = resultingQueryColumns.find((mapping) => {
+					// Split the column name by the dot
+					const columnNameParts =
+						mapping.column.columnName.split('.');
+					const columnNamePart =
+						columnNameParts[columnNameParts.length - 1];
+
+					if (
+						mapping.column.columnName === columnName ||
+						columnNamePart === columnName
+					) {
+						return true;
+					}
+
+					return false;
+				});
+
+				if (columnMapping) {
+					newRow[columnMapping.as] = row[columnName];
+				} else {
+					newRow[columnName] = row[columnName];
+				}
+			});
+
+			// Remove any property of the row that isn't present in the 'allSelectedColumnNames'
+			Object.keys(newRow).forEach((columnName) => {
+				if (!allSelectedColumnNames.includes(columnName)) {
+					delete newRow[columnName];
+				}
+			});
+
+			return newRow;
+		});
+
+		const isPureTable =
+			mainSource.type === 'table' &&
+			!(selectQuery.join as [])?.length &&
+			resultingQueryColumns.every(
+				(column) =>
+					column.as === column.column.columnName &&
+					column.column.table.tableName === mainSource.name
+			);
+
+		const tableName = isPureTable ? mainSource.name : null;
+
+		const entity =
+			mainSource.type === 'table'
+				? this.getTable(tableName)?.entity || null
+				: null;
+
+		const result: ISelectQueryResult = {
+			columns: resultingQueryColumns,
+			rows: mappedRows,
+			tableName: tableName,
+			entity: entity,
+			total: count
+		};
+
+		// Cache the result
+		// @ts-ignore
+		this.onGoingQueryCache[selectStatement.id] = result;
+
+		return result;
+	}
+
+	resolveRawInterpolationValues(
+		query: string,
+		inputs: IDynamicValue[]
+	): string {
+		let queryString = query;
+
+		inputs.forEach((value) => {
+			let valuetoReplaceWithQuotes = `'{{::${value.valueOwner.id}}}'`;
+			let valuetoReplaceWithoutQuotes = `{{::${value.valueOwner.id}}}`;
+
+			let stringifiedValue = '';
+
+			// Use the literal's flattened raw value when available so Array
+			// literals (whose `value` field carries nested
+			// SearchStatementLiteralValue objects) collapse down to plain
+			// primitives / nested arrays before we serialise them. Falling
+			// back to value.value.value preserves behaviour for inputs whose
+			// .value isn't a SearchStatementLiteralValue instance.
+			const innerWrapper: any = value?.value;
+			const flattened =
+				innerWrapper &&
+				typeof innerWrapper.flattenRawValue === 'function'
+					? innerWrapper.flattenRawValue()
+					: innerWrapper?.value;
+
+			const literalValue = flattened;
+
+			if (
+				!value ||
+				!innerWrapper ||
+				(literalValue == null &&
+					literalValue !== false &&
+					literalValue !== 0)
+			) {
+				stringifiedValue = 'NULL';
+			} else if (typeof literalValue === 'string') {
+				stringifiedValue = `'${literalValue}'`;
+			} else if (typeof literalValue === 'boolean') {
+				stringifiedValue = `${literalValue}`;
+			} else if (typeof literalValue === 'number') {
+				stringifiedValue = `${literalValue}`;
+			} else if (Array.isArray(literalValue)) {
+				// Arrays interpolate as JSON-string arrays — same shape produced
+				// by SearchStatementLiteralValue.toQuery() for Array literals,
+				// so they round-trip through unnest()/array-typed function args
+				// without further coercion.
+				stringifiedValue = `'${JSON.stringify(literalValue)}'`;
+			}
+
+			// @ts-ignore
+			queryString = queryString.replaceAll(
+				valuetoReplaceWithQuotes,
+				stringifiedValue
+			);
+
+			// @ts-ignore
+			queryString = queryString.replaceAll(
+				valuetoReplaceWithoutQuotes,
+				stringifiedValue
+			);
+		});
+
+		return queryString;
+	}
+
+	async run(
+		sql: Program,
+		inputs: IDynamicValue[] = []
+	): Promise<ISelectQueryResult> {
+		toLower(sql);
+
+		let queryString = this.resolveRawInterpolationValues(
+			SQLASTLib.show(sql),
+			inputs
+		);
+
+		const sanitizedAST = SQLASTLib.parse(queryString, {
+			dialect: 'sqlite',
+			// These are optional:
+			includeSpaces: true // Adds spaces/tabs
+			// includeNewlines: true, // Adds newlines
+			// includeComments: true, // Adds comments
+			// includeRange: true, // Adds source code location data
+		});
+
+		const selectStatement =
+			searchStatementUtils.getSelectStatementFromProgram(sanitizedAST);
+
+		let result: ISelectQueryResult = null;
+
+		if (!!selectStatement) {
+			result = await this.processSelectQuery(selectStatement);
+		}
+
+		this.onGoingQueryCache = {};
+
+		return result;
+	}
+}
+
+/*
+  This class is responsible for managing the local indexed databases for the project
+	and is the main interface for interacting with them
+
+  The constructor takes a project state
+  Then searches for any instances of custom entities that extend the base 'relational database' entity
+  For each database entity, it initializes (creates or reuses) a local indexed database
+
+  The class holds a list of active local dbs as well as utilities to interact with them
+*/
+export class LocalRelationalDatabasesStore {
+	project: EditorService;
+
+	databases: Database[] = [];
+
+	constructor(project: EditorService) {
+		this.project = project;
+
+		this.initDb = this.initDb.bind(this);
+		this.init = this.init.bind(this);
+		this.destroy = this.destroy.bind(this);
+		this.addDatabase = this.addDatabase.bind(this);
+		this.getDatabase = this.getDatabase.bind(this);
+		this.getDatabaseForPersistedEntity =
+			this.getDatabaseForPersistedEntity.bind(this);
+		this.onPersistedEntityAdded = this.onPersistedEntityAdded.bind(this);
+		this.onPersistedEntityRemoved =
+			this.onPersistedEntityRemoved.bind(this);
+		this.onPersistedEntityUpdated =
+			this.onPersistedEntityUpdated.bind(this);
+		this.onDatabaseEntityAdded = this.onDatabaseEntityAdded.bind(this);
+		this.onDatabaseEntityRemoved = this.onDatabaseEntityRemoved.bind(this);
+		this.onDatabaseEntityUpdated = this.onDatabaseEntityUpdated.bind(this);
+	}
+
+	// These are the user declared entities that represent a relational db
+	get databaseEntities(): DefinitionEntityState[] {
+		return this.project.logic.entities.filter((entity) =>
+			checkHasBaseEntity(entity, BaseEntityNames.RELATIONAL_DATABASE)
+		);
+	}
+
+	// These are the user declared entities that are stored in the relational db as a table
+	get persistedEntities(): DefinitionEntityState[] {
+		return this.project.logic.entities.filter((entity) =>
+			checkHasBaseEntity(entity, BaseEntityNames.PERSISTED_ENTITY)
+		);
+	}
+
+	onPersistedEntityAdded(entity: DefinitionEntityState) {
+		if (checkHasBaseEntity(entity, BaseEntityNames.PERSISTED_ENTITY)) {
+			if (!this.persistedEntities.find((e) => e.id === entity.id)) {
+				this.persistedEntities.push(entity);
+			}
+
+			// Find and then sync the parent db
+			const db = this.getDatabaseForPersistedEntity(entity);
+
+			if (db) {
+				this.initDb(db.entity);
+			}
+		}
+	}
+
+	onPersistedEntityRemoved(entity: DefinitionEntityState) {
+		if (checkHasBaseEntity(entity, BaseEntityNames.PERSISTED_ENTITY)) {
+			// Find and then sync the parent db
+			const db = this.getDatabaseForPersistedEntity(entity);
+
+			if (db) {
+				this.initDb(db.entity);
+			}
+		}
+	}
+
+	onPersistedEntityUpdated(entity: DefinitionEntityState) {
+		if (checkHasBaseEntity(entity, BaseEntityNames.PERSISTED_ENTITY)) {
+			// Find and then sync the parent db
+			const db = this.getDatabaseForPersistedEntity(entity);
+
+			if (db) {
+				this.initDb(db.entity);
+			}
+		}
+	}
+
+	onDatabaseEntityAdded(entity: DefinitionEntityState) {
+		if (checkHasBaseEntity(entity, BaseEntityNames.RELATIONAL_DATABASE)) {
+			if (!this.databaseEntities.find((e) => e.id === entity.id)) {
+				this.databaseEntities.push(entity);
+			}
+
+			// Improve syncing of the db
+			this.initDb(entity);
+		}
+	}
+
+	onDatabaseEntityRemoved(entity: DefinitionEntityState) {
+		if (checkHasBaseEntity(entity, BaseEntityNames.RELATIONAL_DATABASE)) {
+			const db = this.getDatabase(entity.id);
+
+			if (db) {
+				this.databases = this.databases.filter(
+					(db) => db.entity.id !== entity.id
+				);
+				db.destroy();
+			}
+		}
+	}
+
+	onDatabaseEntityUpdated(entity: DefinitionEntityState) {
+		// Find the db and reinitialize it
+		// if the name is what has changed, delete the old db and create a new one
+		const db = this.getDatabase(entity.id);
+
+		if (db) {
+			const dbName = Database.toDbName(entity);
+
+			if (db.connection?.database?.name !== dbName) {
+				db.destroy();
+			}
+
+			this.initDb(entity);
+		}
+	}
+
+	async init(): Promise<void> {
+		await Promise.all(this.databaseEntities.map(this.initDb));
+
+		// Listen for changes to the project state
+		// And modify the databases accordingly
+		this.project.logic.on(
+			ProjectStateEvents.PERSISTED_DEFINITION_ENTITY_ADDED,
+			this.onPersistedEntityAdded
+		);
+		this.project.logic.on(
+			ProjectStateEvents.PERSISTED_DEFINITION_ENTITY_REMOVED,
+			this.onPersistedEntityRemoved
+		);
+		this.project.logic.on(
+			ProjectStateEvents.PERSISTED_DEFINITION_ENTITY_UPDATED,
+			this.onPersistedEntityUpdated
+		);
+
+		this.project.logic.on(
+			ProjectStateEvents.RELATIONAL_DATABASE_DEFINITION_ENTITY_ADDED,
+			this.onDatabaseEntityAdded
+		);
+		this.project.logic.on(
+			ProjectStateEvents.RELATIONAL_DATABASE_DEFINITION_ENTITY_REMOVED,
+			this.onDatabaseEntityRemoved
+		);
+		this.project.logic.on(
+			ProjectStateEvents.RELATIONAL_DATABASE_DEFINITION_ENTITY_UPDATED,
+			this.onDatabaseEntityUpdated
+		);
+	}
+
+	async destroy(): Promise<void> {
+		await Promise.all(this.databases.map((db) => db.disconnect()));
+
+		this.databases = [];
+		this.project = null;
+
+		this.project?.logic?.off(
+			ProjectStateEvents.PERSISTED_DEFINITION_ENTITY_ADDED,
+			this.onPersistedEntityAdded
+		);
+		this.project?.logic?.off(
+			ProjectStateEvents.PERSISTED_DEFINITION_ENTITY_REMOVED,
+			this.onPersistedEntityRemoved
+		);
+		this.project?.logic?.off(
+			ProjectStateEvents.PERSISTED_DEFINITION_ENTITY_UPDATED,
+			this.onPersistedEntityUpdated
+		);
+		this.project?.logic?.off(
+			ProjectStateEvents.RELATIONAL_DATABASE_DEFINITION_ENTITY_ADDED,
+			this.onDatabaseEntityAdded
+		);
+		this.project?.logic?.off(
+			ProjectStateEvents.RELATIONAL_DATABASE_DEFINITION_ENTITY_REMOVED,
+			this.onDatabaseEntityRemoved
+		);
+		this.project?.logic?.off(
+			ProjectStateEvents.RELATIONAL_DATABASE_DEFINITION_ENTITY_UPDATED,
+			this.onDatabaseEntityUpdated
+		);
+	}
+
+	async initDb(entity: DefinitionEntityState): Promise<Database> {
+		const database =
+			this.getDatabase(entity.id) || new Database(entity, this);
+
+		try {
+			await database.init();
+		} catch (e) {
+			console.error(
+				`Error initializing local db for ${resolveEntityName(
+					entity,
+					this.project.logic
+				)}: `,
+				e
+			);
+		}
+
+		const savedDatabase = this.addDatabase(database);
+
+		return savedDatabase;
+	}
+
+	addDatabase(database: Database): Database {
+		let existingDatabase: Database = this.databases.find(
+			(db) =>
+				db === database ||
+				db.connection === database.connection ||
+				db.connection?.database?.name ===
+					database.connection?.database?.name ||
+				db.entity.id === database.entity.id
+		);
+
+		// If it doesn't yet exist, add it to the list of active dbs
+		if (!existingDatabase) {
+			this.databases.push(database);
+
+			return database;
+		}
+
+		return existingDatabase;
+	}
+
+	// Given a definition entity that extends the built in persisted entity
+	// It returns the database instance that owns the table for this entity
+	getDatabaseForPersistedEntity(entity: DefinitionEntityState): Database {
+		const databaseEntity =
+			resolvePersistedDefinitionEntityDatabaseEntity(entity);
+
+		if (!databaseEntity) {
+			return null;
+		}
+
+		const database = this.databases.find((db) => {
+			return db.entity.id === databaseEntity.id;
+		});
+
+		return database;
+	}
+
+	getDatabase(entityId: string): Database {
+		return this.databases.find((db) => db.entity.id === entityId);
+	}
+}
+
+export async function browserSearchImplementation(
+	entity: SearchState,
+	inputs: IDynamicValue[],
+	project: EditorService
+): Promise<{
+	// @ts-ignore
+	error: string | null;
+	[dataPropertyName: string]:
+		| {
+				[columnName: string]: any;
+		  }
+		| null
+		| {
+				[columnName: string]: any;
+		  }[];
+}> {
+	const initialAst = searchStatementUtils.sanitizeQuery(entity.query)
+		? SQLASTLib.parse(searchStatementUtils.sanitizeQuery(entity.query), {
+				dialect: 'sqlite'
+			})
+		: null;
+
+	const hydratedStateConfig =
+		searchStatementUtils.hydrateSearchStatementState(
+			initialAst,
+			project.logic,
+			entity
+		);
+
+	if (!!hydratedStateConfig.errors.length) {
+		// Do nothing
+	}
+
+	const searchStatementState = hydratedStateConfig.state;
+
+	// Based on the main data source, we resolve the database client
+	const resolveDatabaseClient = (): Database | null => {
+		if (!!searchStatementState?.from) {
+			const mainDataSourceEntity =
+				searchStatementState?.mainPersistedEntity || null;
+
+			if (!mainDataSourceEntity) {
+				return null;
+			}
+
+			const database =
+				project?.localDatabaseStore?.getDatabaseForPersistedEntity(
+					mainDataSourceEntity
+				);
+
+			return database;
+		} else {
+			// There is no need for any table to be present, so we just need ANY client, to query against
+			return project?.localDatabaseStore?.databases[0] || null;
+		}
+	};
+
+	const dbClient = resolveDatabaseClient();
+
+	const newResult: ISelectQueryResultV2 = (await dbClient?.runStatement(
+		searchStatementState,
+		inputs
+	)) as ISelectQueryResultV2;
+
+	const newValue = searchStatementState.asList
+		? newResult?.rows
+		: newResult?.rows[0] || null;
+
+	const resultDT = entity.getDataType(null);
+	if (
+		resultDT?.entity.type === EntityType.DefinitionEntity &&
+		!!resultDT?.entity.properties[0]
+	) {
+		const foundOutputMap = entity.outputs.find(
+			(output) =>
+				output.declaration?.id ===
+				(resultDT.entity as DefinitionEntityState)?.properties[0].id
+		);
+
+		const dataPropertyName = foundOutputMap
+			? foundOutputMap.codeName ||
+				foundOutputMap.declaration?.codeName ||
+				toCamelCase(resolveEntityName(foundOutputMap, entity.project))
+			: toCamelCase(resolveEntityName(resultDT.entity, entity.project)) ||
+				'data';
+
+		return {
+			[dataPropertyName]: newValue,
+			error: null
+		};
+	}
+
+	return {
+		data: newValue,
+		error: null
+	};
+}