masquerade-orm 0.1.0

package/src/entity/entity.js

@@ -0,0 +1,228 @@
+
+
+import { ChangeLogger } from "../changeLogger/changeLogger.js"
+import { dependenciesSymb, referencesSymb } from "../misc/constants.js"
+import { nonSnake2Snake } from "../misc/miscFunctions.js"
+import { OrmStore } from "../misc/ormStore.js"
+import { insertProxyIntoEntityMap, proxifyEntityInstanceObj } from "../proxies/instanceProxy.js"
+import { throwDeletionErr, throwImproperDecouplingErr, validateDependentDataDecoupling } from "./delete/delete.js"
+import { insertDependentsData, internalFind } from "./delete/getDependents.js"
+import { aliasedFindWiki2QueryRes, parseFindWiki, destructureAndValidateArg } from "./find/find.js"
+import { deproxifyScopeProxy, classWiki2ScopeProxy } from "./find/scopeProxies.js"
+import { postgresCreateProxyArray } from "./find/sqlClients/postgresFuncs.js"
+import { sqliteCreateProxyArray } from "./find/sqlClients/sqliteFuncs.js"
+import { mergeRelationalWhereScope } from "./find/where/relationalWhere.js"
+import { mergeWhereScope } from "./find/where/where.js"
+
+/**
+ * @template T
+ * @typedef {import("../misc/types").FindObj<T>} FindObj
+ */
+
+export class Entity {
+  //@ts-ignore
+  /**@type {string | number}*/ id
+  /**@type {Date}*/ updatedAt
+
+  /** @abstract */
+  constructor() {
+    const className = this.constructor.name
+
+    const { classWikiDict, idLogger, entityMapsObj } = OrmStore.store
+    if (!classWikiDict) throw new Error("ORM is not initialized. Please call the appropriate ORM boot method before use.")
+    else if (!classWikiDict[className]) throw new Error(`Cannot create an instance of class '${className}' since it is an abstract class.`)
+
+    let idVal
+    if (typeof idLogger[className] === `function`) idVal = idLogger[className]()
+    else idVal = ++idLogger[className]
+
+    Object.defineProperty(this, 'id', {
+      value: idVal,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    })
+    this.updatedAt = new Date()
+
+    const proxy = proxifyEntityInstanceObj(this)
+    const entityMap = entityMapsObj[className] ??= new Map()
+    insertProxyIntoEntityMap(proxy, entityMap)
+    ChangeLogger.flushChanges()
+    return proxy
+  }
+
+  /**
+   * Finds instances in the database that match the given argument.
+   * Relations do not get filtered by any where condition, only the root instances get filtered.
+   * (RootClass.find(arg)) => only RootClass instances matching the arg's where conditions get returned. 
+   *
+     * @template T
+     * @this {{ new(...args: any[]): T }}
+     * @param {FindObj<T>} findObj
+     * @returns {Promise<T[]>}
+     */
+  static async find(findObj) {
+    const { dbConnection, sqlClient, entities, classWikiDict } = OrmStore.store
+    if (!dbConnection) throw new Error("ORM is not initialized. Please call the appropriate ORM boot method before use.")
+    if (ChangeLogger.scheduledFlush) await ChangeLogger.save()
+
+    let classWiki = classWikiDict[this.name]
+    if (!classWiki) throw new Error(`The class '${this.name}' has not been included in the ORM boot method.`)
+    const [relationsArg, whereArg, relationalWhereArg] = destructureAndValidateArg(findObj)
+    let findWiki
+    const baseProxyMap = classWiki2ScopeProxy(classWiki)
+    if (whereArg) mergeWhereScope(baseProxyMap, whereArg)
+    if (relationalWhereArg) findWiki = mergeRelationalWhereScope(baseProxyMap, relationalWhereArg)
+    findWiki = deproxifyScopeProxy(baseProxyMap)
+
+    const [aliasedFindMap, joinStatements, whereObj] = parseFindWiki(findWiki)
+    const [queryResult, relationsScopeObj] = await aliasedFindWiki2QueryRes(aliasedFindMap, joinStatements, whereObj, relationsArg, classWiki, dbConnection)
+    const instanceArr = sqlClient === "postgresql"
+      ? postgresCreateProxyArray(queryResult, relationsScopeObj, entities, relationsArg)
+      : sqliteCreateProxyArray(queryResult, relationsScopeObj, entities, relationsArg)
+
+    return instanceArr
+  }
+
+  // async save() {
+  //   const { dbConnection, classWikiDict } = OrmStore.store
+  //   if (!dbConnection) throw new Error("ORM is not initialized. Please call the appropriate ORM boot method before use.")
+  //   const className = this.constructor.name
+  //   let classWiki = classWikiDict[className]
+
+  //   const branchesCteArray = []
+  //   const createdInstacesLogger = []
+
+  //   newRootInsertionCte(this, classWiki, branchesCteArray, createdInstacesLogger)
+  //   let queryObj = parseInsertionQueryObj(branchesCteArray)
+
+  //   try {
+  //     //@ts-ignore
+  //     await pool.query(queryObj.queryStr, queryObj.values)
+  //   }
+  //   catch (e) {
+  //     console.warn(e)
+  //   }
+  // }
+
+  /**
+  * Hard deletes the instance from the database. May require a pre-deletion step - the 'getDependents' method.
+  */
+  async delete() {
+    const { dbConnection, classWikiDict, dependentsMapsObj, dbChangesObj } = OrmStore.store
+    if (!dbConnection) throw new Error("ORM is not initialized. Please call the appropriate ORM boot method before use.")
+
+    const id4Deletion = this.id
+    const className = this.constructor.name
+    let classWiki = classWikiDict[className]
+    const dependencyContext = classWiki[dependenciesSymb]
+    if (dependencyContext) {
+      let dependentsData
+      if (!dependentsMapsObj[className]) throwDeletionErr(className, id4Deletion)
+      else dependentsData = dependentsMapsObj[className].get(id4Deletion)
+
+      dependentsData = dependentsData.deref()
+      const isValid = validateDependentDataDecoupling(dependentsData, id4Deletion)
+      if (!isValid) throwImproperDecouplingErr(className, id4Deletion)
+    }
+
+    //@ts-ignore
+    const emitter = this.eEmitter_
+    emitter.dispatchEvent(
+      new CustomEvent("delete", {
+        detail: {
+          id: id4Deletion
+        }
+      })
+    )
+
+    let targetTableName
+
+    if (classWiki.parent) {
+      let currentWiki = classWiki
+      while (currentWiki.parent) {
+        targetTableName = currentWiki.parent.className
+        currentWiki = currentWiki.parent
+      }
+    }
+    else targetTableName = className
+
+    dbChangesObj.deletedInstancesArr ??= []
+    dbChangesObj.deletedInstancesArr.push([nonSnake2Snake(targetTableName), id4Deletion])
+    if (dbChangesObj[className] && dbChangesObj[className][id4Deletion]) delete dbChangesObj[className][id4Deletion]
+
+    //@ts-ignore
+    this.source_._isDeleted_ = true
+    ChangeLogger.flushChanges()
+  }
+
+  /**
+  * A pre-deletion step that is required in certain cases.
+  * Finds all instances that have a one-to-one relationship with the calling instance
+  * where the related property cannot be set to `undefined`.
+  * These relationships must be reassigned before the calling instance
+  * can be safely deleted.
+  */
+  async getDependents() {
+    if (!this.id) return undefined
+    const returnedObj = {}
+    const className = this.constructor.name
+    const dependedOnId = this.id
+    const { classWikiDict, dependentsMapsObj } = OrmStore.store
+
+    const classWiki = classWikiDict[className]
+    const dependencyContext = classWiki[dependenciesSymb]
+    if (!dependencyContext) return undefined
+
+    for (const [className, relationalProps] of Object.entries(dependencyContext)) {
+      const dependentMap = classWikiDict[className]
+      returnedObj[className] = [await internalFind(dependentMap, relationalProps, dependedOnId), relationalProps]
+    }
+    insertDependentsData(className, dependedOnId, returnedObj, dependentsMapsObj)
+    return returnedObj
+  }
+
+  /**
+   * Finds all instances that have a relation with the calling instance,
+   * This method is a superset of the getDependents method, and is not meant as a pre-deletion step, but as a utility.
+   */
+  async getReferencers() {
+    if (!this.id) return undefined
+    const returnedObj = {}
+    const className = this.constructor.name
+    const referencedId = this.id
+    const { classWikiDict, dependentsMapsObj } = OrmStore.store
+    const classWiki = classWikiDict[className]
+
+    const referencesContext = classWiki[referencesSymb]
+
+    if (referencesContext) {
+      for (const [className, relationalProps] of Object.entries(referencesContext ?? {})) {
+        const referencesMap = classWikiDict[className]
+        returnedObj[className] = [await internalFind(referencesMap, relationalProps, referencedId), relationalProps]
+      }
+    }
+
+    const dependencyContext = classWiki[dependenciesSymb]
+    if (!dependencyContext) {
+      if (!referencesContext) return undefined
+      return returnedObj
+    }
+
+    const dependentsDataObj = {}
+    for (const [className, relationalProps] of Object.entries(dependencyContext)) {
+      const dependentMap = classWikiDict[className]
+      const dependentInstanceArr = await internalFind(dependentMap, relationalProps, referencedId)
+      dependentsDataObj[className] = [dependentInstanceArr, relationalProps]
+      if (!returnedObj[className]) returnedObj[className] = [dependentInstanceArr, relationalProps]
+      else {
+        returnedObj[className][0].push(...dependentInstanceArr)
+        let uniqueDependentInstances = [...new Set(returnedObj[className][0])]
+        returnedObj[className][0] = [...uniqueDependentInstances]
+        returnedObj[className][1].push(...relationalProps)
+      }
+    }
+    insertDependentsData(className, referencedId, dependentsDataObj, dependentsMapsObj)
+    return returnedObj
+  }
+}

package/src/entity/find/find.js

@@ -0,0 +1,157 @@
+
+import { coloredBackgroundConsoleLog, getType, jsValue2SqliteValue, postgres2sqliteQueryStr } from "../../misc/miscFunctions.js"
+import { rowObj2InstanceProxy } from "../../proxies/instanceProxy.js"
+import { createRelationalArrayProxy } from "../../proxies/relationalArrayProxy.js"
+import { generateQueryStrWithCTEs } from "./queryBuilder.js"
+import { junctionJoin, parentJoin } from "./joins.js"
+import { relationalWhereFuncs2Statements } from "./where/relationalWhere.js"
+import { whereValues2Statements } from "./where/where.js"
+import { OrmStore } from "../../misc/ormStore.js"
+
+export const proxyType = Symbol('proxyType')
+
+export function destructureAndValidateArg(findObj) {
+    let { relations: eagerLoad, where, relationalWhere } = findObj
+
+    if (eagerLoad) {
+        const type = getType(eagerLoad)
+        if (type !== "object") throw new Error(`\nInvalid value in the 'eagerLoad' field of the 'find' function's argument. Expected an object.`)
+        else if (Object.keys(eagerLoad).length === 0) eagerLoad = undefined
+    }
+
+    if (where) {
+        const type = getType(where)
+        if (type !== "object") throw new Error(`\nInvalid value in the 'where' field of the 'find' function's argument. Expected an object.`)
+        else if (Object.keys(where).length === 0) where = undefined
+    }
+
+    if (relationalWhere) {
+        const type = getType(relationalWhere)
+        if (type !== "function") throw new Error(`\nInvalid value in the 'relationalWhere' field of the 'find' function's argument. Expected a function.`)
+    }
+    return [eagerLoad, where, relationalWhere]
+}
+
+export function removeRelationFromUnusedRelations(classMap, key) {
+    const filteredUnusedRelations = Object.fromEntries(
+        Object.entries(classMap.uncalledJunctions_).filter(([prop, val]) => prop !== key)
+    )
+    classMap.uncalledJunctions_ = filteredUnusedRelations
+}
+
+export function parseFindWiki(findWiki, aliasBase = 'a', aliasArr = [], joinStatements = [], whereObj = { statements: [], params: [] }, selectArr = []) {
+    let returnedWiki = findWiki
+    if (aliasBase === 'a') {
+        returnedWiki = {}
+        for (const key of Object.keys(findWiki)) returnedWiki[key.slice(0, -1)] = findWiki[key]
+    }
+    const alias = returnedWiki.alias = `${aliasBase}${aliasArr.length + 1}`
+    aliasArr.push(alias)
+
+    let parent = returnedWiki.parent
+    if (parent) {
+        const parentAlias = `${aliasBase}${aliasArr.length + 1}`
+        if (aliasBase === 'a') joinStatements.push(parentJoin(parent, parentAlias, returnedWiki))
+        returnedWiki.parent = parseFindWiki(parent, aliasBase, aliasArr, joinStatements, whereObj, selectArr)[0]
+    }
+
+    if (returnedWiki.junctions) {
+        for (const key of Object.keys(returnedWiki.junctions)) {
+            const joinedTable = returnedWiki.junctions[key]
+            const joinedTableAlias = `${aliasBase}${aliasArr.length + 1}`
+            if (aliasBase === 'a') joinStatements.push(junctionJoin(joinedTable, joinedTableAlias, returnedWiki, key))
+            returnedWiki.junctions[key] = parseFindWiki(joinedTable, aliasBase, aliasArr, joinStatements, whereObj, selectArr)[0]
+        }
+    }
+    if (returnedWiki.relationalWhere) relationalWhereFuncs2Statements(returnedWiki, whereObj)
+    if (returnedWiki.where) whereValues2Statements(returnedWiki, whereObj)
+    return [returnedWiki, joinStatements, whereObj, selectArr]
+}
+
+export async function aliasedFindWiki2QueryRes(aliasedFindWiki, joinStatements, whereObj, eagerLoadObj, classWiki, dbConnection, forInternalFind = false) {
+    const sqlClient = OrmStore.store.sqlClient
+    let [queryString, relationsScope] = generateQueryStrWithCTEs(aliasedFindWiki, joinStatements, whereObj, eagerLoadObj, classWiki, sqlClient)
+    //@ts-ignore
+    if (forInternalFind) queryString = queryString.replace(/\bAND\b/g, `OR`)
+    try {
+        let queryResult
+        if (sqlClient === "postgresql") queryResult = (await dbConnection.query(queryString, whereObj.params)).rows
+        else {
+            const formattedParams = []
+            for (const param of whereObj.params) formattedParams.push(jsValue2SqliteValue(param))
+            queryResult = dbConnection.prepare(postgres2sqliteQueryStr(queryString)).all(...formattedParams)
+        }
+        return [queryResult, relationsScope]
+    }
+    catch (e) {
+        coloredBackgroundConsoleLog(`Find failed. ${e}\n`, `failure`)
+        return []
+    }
+}
+
+export function findColumnObjOnWiki(propertyName, scopedWiki) {
+    let currentWiki = scopedWiki
+    let columnObj
+    while (!columnObj) {
+        columnObj = currentWiki.columns[propertyName]
+        currentWiki = currentWiki.parent
+    }
+    return columnObj
+}
+
+export function junctionProp2Wiki(scopedWiki, propertyName) {
+    let mapWithJunction
+    if (scopedWiki.junctions[propertyName]) mapWithJunction = scopedWiki.junctions[propertyName]
+    else {
+        let currentParent = scopedWiki.parent
+        while (!currentParent.junctions[propertyName]) currentParent = currentParent.parent
+        mapWithJunction = currentParent.junctions[propertyName]
+    }
+    return mapWithJunction
+}
+
+export function fillCalledRelationsOnInstance(instance, resultObj, scopedWiki, relationalProperties2Add, Entities) {
+    for (const propertyName of relationalProperties2Add) {
+        const scopedMap4Junction = junctionProp2Wiki(scopedWiki, propertyName)
+        if (scopedMap4Junction.isArray) {
+            if (!resultObj[propertyName].length) {
+                instance[propertyName] = createRelationalArrayProxy(instance, propertyName)
+                continue
+            }
+
+            instance[propertyName] = []
+            for (let i = 0; i < resultObj[propertyName].length; i++) {
+                const instanceProxy = rowObj2InstanceProxy(resultObj[propertyName][i], scopedMap4Junction, Entities)
+                instance[propertyName][i] = instanceProxy
+            }
+            instance[propertyName] = createRelationalArrayProxy(instance, propertyName, instance[propertyName])
+        }
+        else {
+            instance[propertyName] = undefined
+            if (!resultObj[propertyName]) continue
+            const instanceProxy = rowObj2InstanceProxy(resultObj[propertyName], scopedMap4Junction, Entities)
+            instance[propertyName] = instanceProxy
+        }
+    }
+}
+
+export function getRelationalPropNames(classWiki, only1To1Relations = false) {
+    let relationalPropsEntries = Object.entries(classWiki.junctions ?? {})
+    let currentWiki = classWiki
+    while (currentWiki.parent) {
+        let parentRelationalPropEntries = Object.entries(currentWiki.parent.junctions ?? {})
+        relationalPropsEntries.push(...parentRelationalPropEntries)
+        currentWiki = currentWiki.parent
+    }
+    if (only1To1Relations) relationalPropsEntries = relationalPropsEntries.filter(([propName, junctionObj]) => !junctionObj.isArray)
+    return relationalPropsEntries.map(([propName, junctionObj]) => propName)
+}
+
+export function traverseResultObjRelationalScope(instanceArrOrInstanceObj, scopedWiki, entitiesFuncsArr) {
+    if (!instanceArrOrInstanceObj) return
+    else if (Array.isArray(instanceArrOrInstanceObj)) {
+        if (!instanceArrOrInstanceObj.length) return
+        for (const instance of instanceArrOrInstanceObj) rowObj2InstanceProxy(instance, scopedWiki, entitiesFuncsArr)
+    }
+    else rowObj2InstanceProxy(instanceArrOrInstanceObj, scopedWiki, entitiesFuncsArr)
+}

package/src/entity/find/joins.js

@@ -0,0 +1,52 @@
+import { nonSnake2Snake } from "../../misc/miscFunctions.js"
+
+export function parentJoin(parentObj, parentAlias, childObj) {
+    const childAlias = childObj.alias
+    const parentName = nonSnake2Snake(parentObj.className_ ?? parentObj.className)
+    return `\nLEFT JOIN ${parentName} ${parentAlias} ON ${parentAlias}.id = ${childAlias}.id`
+}
+
+export function junctionJoin(joinedTable, joinedTableAlias, baseTable, junctionPropertyName) {
+    const baseTableName = nonSnake2Snake(baseTable.className)
+    let baseTableAlias = baseTable.alias
+    const joinedTableName = nonSnake2Snake(joinedTable.className_ ?? joinedTable.className)
+
+    const junctionName = `${baseTableName}___${nonSnake2Snake(junctionPropertyName)}_jt`
+    const junctionAlias = `jt_${baseTableAlias}_${joinedTableAlias}`
+
+    let queryStr = `\nLEFT JOIN ${junctionName} ${junctionAlias} ON ${baseTableAlias}.id = ${junctionAlias}.joining_id `
+    queryStr += ` \nLEFT JOIN ${joinedTableName} ${joinedTableAlias} ON ${junctionAlias}.joined_id = ${joinedTableAlias}.id \n`
+
+    return queryStr
+}
+
+export function junctionJoinCte(joinedTable, baseTable, junctionPropertyName, /**@type {string}*/ sqlClient) {
+    const baseTableName = nonSnake2Snake(baseTable.className)
+    let baseTableAlias = baseTable.alias
+    //const joinedTableName = nonSnake2Snake(joinedTable.className)
+    const joinedTableAlias = joinedTable.alias
+
+    const junctionName = `${baseTableName}___${nonSnake2Snake(junctionPropertyName)}_jt`
+    const junctionAlias = `jt_${baseTableAlias}_${joinedTableAlias}`
+
+    let queryStr = `\nLEFT JOIN ${junctionName} ${junctionAlias} ON ${baseTableAlias}.id = ${junctionAlias}.joining_id `
+    if (sqlClient === 'postgresql') queryStr += ` \nLEFT JOIN ${joinedTableAlias}_cte ${joinedTableAlias} ON ${junctionAlias}.joined_id = ${joinedTableAlias}.id \n`
+    else queryStr += ` \nLEFT JOIN ${joinedTableAlias}_cte ${joinedTableAlias} ON ${junctionAlias}.joined_id = ${joinedTableAlias}.${joinedTableAlias}_id \n`
+    return queryStr
+}
+
+
+export function junctionJoinSelectedCte(joinedTable, baseTable, junctionPropertyName, sqlClient) {
+    const baseTableName = nonSnake2Snake(baseTable.className)
+    let baseTableAlias = baseTable.alias
+    const joinedTableAlias = joinedTable.alias
+
+    const junctionName = `${baseTableName}___${nonSnake2Snake(junctionPropertyName)}_jt`
+    const junctionAlias = `jt_${baseTableAlias}_${joinedTableAlias}`
+
+    let queryStr = `\nLEFT JOIN ${junctionName} ${junctionAlias} ON ${baseTableAlias}.${baseTableAlias}_id = ${junctionAlias}.joining_id `
+
+    if (sqlClient === 'postgresql') queryStr += ` \nLEFT JOIN ${joinedTableAlias}_cte ${joinedTableAlias} ON ${junctionAlias}.joined_id = ${joinedTableAlias}.id \n`
+    else queryStr += ` \nLEFT JOIN ${joinedTableAlias}_cte ${joinedTableAlias} ON ${junctionAlias}.joined_id = ${joinedTableAlias}.${joinedTableAlias}_id \n`
+    return queryStr
+}

package/src/entity/find/queryBuilder.js

@@ -0,0 +1,95 @@
+import { nonSnake2Snake } from "../../misc/miscFunctions.js"
+import { parseFindWiki } from "./find.js"
+import { mergeRelationsScope } from "./relations.js"
+import { deproxifyScopeProxy, classWiki2ScopeProxy } from "./scopeProxies.js"
+import { parentJoin } from "./joins.js"
+import { eagerLoadCTEsPostgres } from "./sqlClients/postgresFuncs.js"
+import { eagerLoadCTEsSqlite } from "./sqlClients/sqliteFuncs.js"
+
+export function generateQueryStrWithCTEs(findWiki, joinStatements, whereObj, eagerLoad, classWiki, sqlClient) {
+    let flatFilteredCte = generateFlatFilteredCte(findWiki, joinStatements, whereObj.statements)
+    let relationsWiki = classWiki2ScopeProxy(classWiki)
+    let eagerLoadCteArr
+
+    if (eagerLoad) {
+        mergeRelationsScope(relationsWiki, eagerLoad)
+        relationsWiki = deproxifyScopeProxy(relationsWiki, true)
+        const columnObj = generateColumnObj(relationsWiki)
+        let rootCte = generateRootCte(relationsWiki, columnObj)
+        const [aliasedFindMap] = parseFindWiki(relationsWiki, 'b')
+        eagerLoadCteArr = generateEagerLoadCTEsArr(aliasedFindMap, columnObj, sqlClient)
+        let queryStr = flatFilteredCte + `, ` + rootCte + `, ` + eagerLoadCteArr.join(`, `)
+        if (sqlClient === `postgresql`) queryStr += ` SELECT json FROM selected_cte`
+        else queryStr += ` SELECT * FROM selected_cte`
+
+        return [queryStr, relationsWiki]
+    }
+    else {
+        relationsWiki = deproxifyScopeProxy(relationsWiki, true)
+        relationsWiki.alias = `b1`
+        const columnObj = generateColumnObj(findWiki, false)
+        let rootCte = generateRootCte(findWiki, columnObj)
+        let queryStr = flatFilteredCte + `, ` + rootCte
+        return [queryStr + ` SELECT * FROM root_cte`, relationsWiki]
+    }
+}
+
+function generateFlatFilteredCte(findWiki, joinStatements, whereStatements, queryStr = ``) {
+    queryStr += `SELECT DISTINCT ${findWiki.alias}.id FROM ${nonSnake2Snake(findWiki.className)} a1 `
+    if (joinStatements.length) queryStr += joinStatements.join(` `) + ` `
+    if (whereStatements.length) queryStr += `WHERE (` + whereStatements.join(`) AND (`) + `) `
+    return `WITH root_ids AS (${queryStr})`
+}
+
+function generateRootCte(findWiki, columnObj, aliasBase = 'b') {
+    let snakeCasedColumnNames2dArr = [Object.values(columnObj[findWiki.className])]
+    let joinStatements = []
+    if (findWiki.parent) {
+        let currentWiki = findWiki
+        let i = 1
+        while (currentWiki.parent) {
+            currentWiki.alias = `${aliasBase}${i}`
+            const parentName = currentWiki.parent.className
+
+            let parentColumnsArr = Object.values(columnObj[parentName])
+            const index = parentColumnsArr.indexOf(`id`)
+            parentColumnsArr.splice(index, 1)
+            snakeCasedColumnNames2dArr.push(parentColumnsArr)
+
+            joinStatements.push(parentJoin(currentWiki.parent, `${aliasBase}${++i}`, currentWiki))
+            currentWiki = currentWiki.parent
+        }
+        currentWiki.alias = `${aliasBase}${i}`
+    }
+
+    let columnNamingStr = ``
+    for (const [index, arr] of snakeCasedColumnNames2dArr.entries())
+        columnNamingStr += arr.map(name => `b${index + 1}.${name} AS b1_${name}`).join(`, `) + `, `
+
+    let cteStr = `root_cte AS (SELECT ${columnNamingStr.slice(0, -2)} FROM root_ids r JOIN ${nonSnake2Snake(findWiki.className)} ${aliasBase}1 ON ${aliasBase}1.id = r.id`
+    if (findWiki.parent) return cteStr + ` ` + joinStatements.join(` `) + `)`
+    else return cteStr + `)`
+}
+
+
+function generateEagerLoadCTEsArr(findWiki, columnObj, sqlClient) {
+    if (sqlClient === "postgresql") return eagerLoadCTEsPostgres(findWiki, [], true)
+    else return eagerLoadCTEsSqlite(findWiki, columnObj)
+}
+
+
+function generateColumnObj(findWiki, relationalRecusrion = true, columnObj = {}) {
+    const className = findWiki.className
+    if (columnObj[className]) return
+
+    const classColumnObj = columnObj[className] = {}
+    const columnNames = Object.keys(findWiki.columns)
+    for (const columnName of columnNames) classColumnObj[columnName] = nonSnake2Snake(columnName)
+
+    if (findWiki.parent) generateColumnObj(findWiki.parent, relationalRecusrion, columnObj)
+    const relations = findWiki.junctions
+    if (relations && relationalRecusrion) {
+        for (const key of Object.keys(relations)) generateColumnObj(relations[key], relationalRecusrion, columnObj)
+    }
+    return columnObj
+}

package/src/entity/find/relations.js

@@ -0,0 +1,23 @@
+import { removeRelationFromUnusedRelations } from "./find.js"
+import { classWiki2ScopeProxy } from "./scopeProxies.js"
+
+export function mergeRelationsScope(scopeProxy, relationsObj) {
+    if (relationsObj === true) return
+    else if (!(relationsObj instanceof Object) || Array.isArray(relationsObj))
+        throw new Error
+            (
+                `\nThe 'relations' field of the find function's argument must be an object with values of either boolean trues or objects.`
+            )
+
+    const relationEntries = Object.entries(relationsObj)
+    for (const [key, objOrTrue] of relationEntries) {
+        const [value, classMap, keyCategory] = scopeProxy[key]
+        if (keyCategory !== "uncalledJunctions_") throw new Error(`\n'${key}' is not a valid relational property of class ${scopeProxy.className_}.`)
+        else {
+            removeRelationFromUnusedRelations(classMap, key)
+            classMap.junctions_ ??= {}
+            classMap.junctions_[key] = classWiki2ScopeProxy(value)
+            if (objOrTrue) mergeRelationsScope(classMap.junctions_[key], objOrTrue)
+        }
+    }
+}

package/src/entity/find/scopeProxies.js

@@ -0,0 +1,60 @@
+import { proxyType } from "./find.js"
+
+export function classWiki2ScopeObj(classWiki) {
+    const scopeProxy = {
+        className_: classWiki.className ?? classWiki.className_,
+        columns_: classWiki.columns ?? classWiki.columns_,
+        uncalledJunctions_: classWiki.junctions ?? classWiki.junctions_,
+    }
+    if (classWiki.isArray || classWiki.isArray_) scopeProxy.isArray_ = true
+    return scopeProxy
+}
+
+export function deproxifyScopeProxy(scopeProxy, fixPropertyNames = false) {
+    scopeProxy = scopeProxy.raw_
+    if (scopeProxy.parent_) scopeProxy.parent_ = deproxifyScopeProxy(scopeProxy.parent_, fixPropertyNames)
+
+    if (scopeProxy.junctions_) {
+        for (const key of Object.keys(scopeProxy.junctions_))
+            scopeProxy.junctions_[key] = deproxifyScopeProxy(scopeProxy.junctions_[key], fixPropertyNames)
+    }
+
+    if (fixPropertyNames) {
+        const fixedMap = {}
+        for (const property of Object.keys(scopeProxy)) fixedMap[property.slice(0, -1)] = scopeProxy[property]
+        return fixedMap
+    }
+    return scopeProxy
+}
+
+export function classWiki2ScopeProxy(classWiki) {
+    const scopeObj = classWiki2ScopeObj(classWiki)
+    if (classWiki.parent) scopeObj.parent_ = classWiki2ScopeProxy(classWiki.parent)
+
+    const proxy = new Proxy(scopeObj, {
+        get: (target, key, reciever) => {
+            if (
+                key === "className_"
+                || key === "parent_"
+                || key === "columns_"
+                || key === "uncalledJunctions_"
+                || key === "junctions_"
+                || key === "where_"
+                || key === "relationalWhere_"
+                || key === "isArray_"
+            ) return target[key]
+            else if (key === proxyType) return 'categorizingProxy'
+            else if (key === "raw_") return target
+            else return findPropOnScopeProxy(target, key, classWiki.className)
+        },
+    })
+    return proxy
+}
+
+export function findPropOnScopeProxy(scopeProxy, key, rootClassName) {
+    if (scopeProxy.columns_[key]) return [scopeProxy.columns_[key], scopeProxy, "columns_"]
+    else if (scopeProxy.uncalledJunctions_ && scopeProxy.uncalledJunctions_[key]) return [scopeProxy.uncalledJunctions_[key], scopeProxy, "uncalledJunctions_"]
+    else if (scopeProxy.junctions_ && scopeProxy.junctions_[key]) return [scopeProxy.junctions_[key], scopeProxy, "junctions_"]
+    else if (scopeProxy.parent_) return findPropOnScopeProxy(scopeProxy.parent_, key, rootClassName)
+    else throw new Error(`\n'${key}' is not a valid property of class ${rootClassName}. Please fix the find function's argument. \nhint: use intellisense by pressing CNTRL + space to see all viable options.`)
+}