masquerade-orm 0.1.0

package/src/entity/find/sqlClients/postgresFuncs.js

@@ -0,0 +1,171 @@
+import { nonSnake2Snake, postgres2JsTyping, snake2Pascal } from "../../../misc/miscFunctions.js"
+import { rowObj2InstanceProxy } from "../../../proxies/instanceProxy.js"
+import { createNonRelationalArrayProxy } from "../../../proxies/nonRelationalArrayProxy.js"
+import { createObjectProxy } from "../../../proxies/objectProxy.js"
+import { findColumnObjOnWiki } from "../find.js"
+import { junctionJoinCte, junctionJoinSelectedCte, parentJoin } from "../joins.js"
+
+export function postgresCreateProxyArray(queryResult, scopeObj, entitiesFuncArr, hadEagerLoading) {
+    if (!queryResult || queryResult.length === 0) return []
+
+    const proxyArr = []
+    for (const row of queryResult) {
+        let resultObj = hadEagerLoading ? row.json : row
+        if (!hadEagerLoading) {
+            const chars2delete = scopeObj.alias.length + 1
+            for (const key of Object.keys(row)) {
+                const newKey = snake2Pascal(key.slice(chars2delete), true)
+                row[newKey] = row[key]
+                delete row[key]
+            }
+        }
+        const filledInstance = rowObj2InstanceProxy(resultObj, scopeObj, entitiesFuncArr)
+        proxyArr.push(filledInstance)
+    }
+    return proxyArr
+}
+
+export function eagerLoadCTEsPostgres(findWiki, cteArr2d = [], isSelectedCte = false, joinsJsonBuildStatements = [], joinStatements = []) {
+    let cteStr = ``
+    let fromStatement = ``
+    const baseAlias = findWiki.alias
+    let mainAndBridgeCteArr = []
+
+    if (isSelectedCte) {
+        const rootCteIdRef = `${baseAlias}.${baseAlias}_id`
+        cteStr += `selected_cte AS ( SELECT ${rootCteIdRef} AS id, jsonb_build_object( 'id', `
+        if (findWiki.columns.id.type === `bigint`) cteStr += `${rootCteIdRef}::text, `
+        else cteStr += `${rootCteIdRef}, `
+        fromStatement += ` FROM root_cte ${baseAlias} `
+
+        let rootCteColumnNames = []
+        let bigintColumnNames = []
+        for (const [columnName, columnObj] of Object.entries(findWiki.columns)) {
+            if (columnObj.type === `bigint`) bigintColumnNames.push(columnName)
+            else rootCteColumnNames.push(columnName)
+        }
+
+        if (findWiki.parent) {
+            let currentWiki = findWiki
+            while (currentWiki.parent) {
+                for (const [columnName, columnObj] of Object.entries(currentWiki.parent.columns)) {
+                    if (columnObj.type === `bigint` && !columnObj.isArray) bigintColumnNames.push(columnName)
+                    else rootCteColumnNames.push(columnName)
+                }
+                currentWiki = currentWiki.parent
+            }
+        }
+
+        bigintColumnNames = bigintColumnNames.filter(columnName => columnName !== `id`)
+        bigintColumnNames = bigintColumnNames.map(columnName => `'${columnName}', ${baseAlias}.${baseAlias}_${nonSnake2Snake(columnName)}::text`)
+        rootCteColumnNames = rootCteColumnNames.filter(columnName => columnName !== `id`)
+        rootCteColumnNames = rootCteColumnNames.map(columnName => `'${columnName}', ${baseAlias}.${baseAlias}_${nonSnake2Snake(columnName)}`)
+
+        if (rootCteColumnNames.length) cteStr += rootCteColumnNames.join(`, `) + `, `
+        if (bigintColumnNames.length) cteStr += bigintColumnNames.join(`, `) + `, `
+
+        const joinedTableEntries = Object.entries(findWiki.junctions)
+
+        for (const [propertyName, joinedTableObj] of joinedTableEntries) {
+            const isJoiningArray = joinedTableObj.isArray
+            if (isJoiningArray) {
+                const bridgeCteAlias = `${baseAlias}${joinedTableObj.alias}`
+                joinsJsonBuildStatements.push(`'${propertyName}', COALESCE(${bridgeCteAlias}.json, '[]'::jsonb)`)
+                joinStatements.push(`LEFT JOIN ${bridgeCteAlias}_cte ${bridgeCteAlias} ON ${baseAlias}.${baseAlias}_id = ${bridgeCteAlias}.id`)
+                mainAndBridgeCteArr.push(one2ManyPostgresBridgeCte(findWiki, joinedTableObj, propertyName))
+            }
+            else {
+                joinsJsonBuildStatements.push(`'${propertyName}', ${joinedTableObj.alias}.json`)
+                joinStatements.push(junctionJoinSelectedCte(joinedTableObj, findWiki, propertyName, 'postgresql'))
+            }
+            eagerLoadCTEsPostgres(joinedTableObj, cteArr2d)
+        }
+        cteStr += joinsJsonBuildStatements.join(`, `) + `) AS json` + fromStatement + joinStatements.join(` `) + `)`
+    }
+    else {
+        const isArray = findWiki.isArray
+        cteStr += `${baseAlias}_cte AS (SELECT ${baseAlias}.id, `
+        fromStatement += ` FROM ${nonSnake2Snake(findWiki.className)} ${baseAlias} `
+
+        let jsonBuildStatementsStr = ``
+        joinsJsonBuildStatements =
+            Object.keys(findWiki.columns)
+                .filter(columnName => columnName !== 'id')
+                .map(columnName => [columnName, baseAlias, findWiki.columns[columnName]])
+
+        let joinStatements = []
+        if (findWiki.parent) {
+            let currentWiki = findWiki
+            while (currentWiki.parent) {
+                const currentParent = currentWiki.parent
+                const parentAlias = currentParent.alias
+                const parentColumns = Object.keys(currentParent.columns)
+                    .filter(columnName => columnName !== 'id')
+                    .map(columnName => [columnName, parentAlias, currentParent.columns[columnName]])
+                joinsJsonBuildStatements.push(...parentColumns)
+                joinStatements.push(parentJoin(currentParent, currentParent.alias, currentWiki))
+                currentWiki = currentParent
+            }
+        }
+        joinsJsonBuildStatements = joinsJsonBuildStatements.map(([columnName, alias, columnObj]) => {
+            if (columnObj.type === `bigint` && !columnObj.isArray) return `'${columnName}', ${alias}.${nonSnake2Snake(columnName)}::text`
+            else return `'${columnName}', ${alias}.${nonSnake2Snake(columnName)}`
+        })
+
+        const joinedTableEntries = Object.entries(findWiki.junctions ?? {})
+
+        for (const [propertyName, joinedTableObj] of joinedTableEntries) {
+            const isJoiningArray = joinedTableObj.isArray
+            if (isJoiningArray) {
+                const bridgeCteAlias = `${findWiki.alias}${joinedTableObj.alias}`
+                joinsJsonBuildStatements.push(`'${propertyName}', COALESCE(${bridgeCteAlias}.json, '[]'::jsonb)`)
+                joinStatements.push(`LEFT JOIN ${bridgeCteAlias}_cte ${bridgeCteAlias} ON ${findWiki.alias}.id = ${bridgeCteAlias}.id`)
+                mainAndBridgeCteArr.push(one2ManyPostgresBridgeCte(findWiki, joinedTableObj, propertyName))
+            }
+            else {
+                joinsJsonBuildStatements.push(`'${propertyName}', ${joinedTableObj.alias}.json`)
+                joinStatements.push(junctionJoinCte(joinedTableObj, findWiki, propertyName, 'postgresql'))
+
+            }
+            eagerLoadCTEsPostgres(joinedTableObj, cteArr2d)
+        }
+        jsonBuildStatementsStr += joinsJsonBuildStatements.join(`, `)
+
+        if (isArray) cteStr += `jsonb_build_object( 'id', ${baseAlias}.id, ${jsonBuildStatementsStr}) `
+        else cteStr += `jsonb_build_object( 'id', ${baseAlias}.id, ${jsonBuildStatementsStr}) `
+
+        cteStr += `AS json` + fromStatement + joinStatements.join(` `) + `)`
+
+    }
+    mainAndBridgeCteArr.push(cteStr)
+    cteArr2d.push(mainAndBridgeCteArr)
+    return cteArr2d
+}
+
+function one2ManyPostgresBridgeCte(baseTable, joinedTable, propertyName) {
+    const baseNameSnaked = nonSnake2Snake(baseTable.className)
+    const baseAlias = baseTable.alias
+    const joinedAlias = joinedTable.alias
+    const junctionName = `${baseNameSnaked}___${nonSnake2Snake(propertyName)}_jt`
+    const junctionAlias = `jt_${baseAlias}_${joinedAlias}`
+    const cteAlias = baseAlias + joinedAlias + `_cte`
+
+    let queryStr = `${cteAlias} AS (SELECT ${junctionAlias}.joining_id AS id, `
+    queryStr += `jsonb_agg(${joinedAlias}.json) AS json `
+    queryStr += `FROM  ${junctionName} ${junctionAlias} `
+    queryStr += `LEFT JOIN ${joinedAlias}_cte ${joinedAlias} ON ${junctionAlias}.joined_id = ${joinedAlias}.id `
+    queryStr += `GROUP BY ${junctionAlias}.joining_id)`
+    return queryStr
+}
+
+
+export function postgresDbValHandling(instance, propertyName, value, scopeObj) {
+    const valType = Array.isArray(value) ? `array` : value instanceof Date ? `date` : typeof value
+    if (valType === `array`) {
+        const isArrayOfObjects = findColumnObjOnWiki(propertyName, scopeObj).type === `object`
+        instance[propertyName] = createNonRelationalArrayProxy(instance, propertyName, value.map(el => el === null ? undefined : el), undefined, isArrayOfObjects)
+    }
+    else if (valType === `object`) instance[propertyName] = createObjectProxy(instance, propertyName, value)
+    else if (valType === `string`) instance[propertyName] = postgres2JsTyping(value, findColumnObjOnWiki(propertyName, scopeObj))
+    else instance[propertyName] = value
+}

package/src/entity/find/sqlClients/sqliteFuncs.js

@@ -0,0 +1,211 @@
+import { nonSnake2Snake, snake2Pascal, sqlite2JsTyping } from "../../../misc/miscFunctions.js"
+import { rowObj2InstanceProxy } from "../../../proxies/instanceProxy.js"
+import { createNonRelationalArrayProxy } from "../../../proxies/nonRelationalArrayProxy.js"
+import { createObjectProxy } from "../../../proxies/objectProxy.js"
+import { findColumnObjOnWiki } from "../find.js"
+import { junctionJoinCte, junctionJoinSelectedCte, parentJoin } from "../joins.js"
+
+export function sqliteCreateProxyArray(resultArray, findWiki, entitiesFuncArr, hadEagerLoading, is4UncalledJunctionPromise = false) {
+    if (resultArray.length === 0) return []
+    const proxyArr = []
+
+    if (!hadEagerLoading) {
+        const chars2delete = findWiki.alias.length + 1
+        for (const row of resultArray) {
+            for (const key of Object.keys(row)) {
+                const newKey = snake2Pascal(key.slice(chars2delete), true)
+                row[newKey] = row[key]
+                delete row[key]
+            }
+            proxyArr.push(rowObj2InstanceProxy(row, findWiki, entitiesFuncArr))
+        }
+        return proxyArr
+    }
+
+    const ledger = {}
+    const instanceWiki = createInstanceWiki(findWiki, is4UncalledJunctionPromise)
+
+    for (const rowObj of resultArray) createNestedClassInstance(rowObj, instanceWiki, ledger, entitiesFuncArr, is4UncalledJunctionPromise)
+    for (const instance of Object.values(ledger)) formatAndproxifyEntityInstanceObj(instance, findWiki, entitiesFuncArr, proxyArr)
+    return proxyArr
+}
+
+
+function createInstanceWiki(findWiki, is4UncalledJunctionPromise) {
+    /**@type {any}*/ const instanceWiki = {
+        alias: findWiki.alias,
+        columns: undefined,
+        junctions: [],
+        propertyName: findWiki.propertyName,
+        className: findWiki.className,
+        isArray: findWiki.isArray,
+        uncalledJunctions: findWiki.uncalledJunctions
+    }
+
+    let instanceColumnsObj = formatColumns(findWiki, is4UncalledJunctionPromise)
+    if (findWiki.junctions) instanceWiki.junctions.push(...formatJunctions4InstanceWiki(findWiki, is4UncalledJunctionPromise))
+    if (findWiki.parent) {
+        let currentAliasMap = findWiki
+        const rootChildAlias = findWiki.alias
+        while (currentAliasMap.parent) {
+            const parentColumnsObj = formatColumns(currentAliasMap.parent, is4UncalledJunctionPromise, rootChildAlias)
+            instanceColumnsObj = { ...instanceColumnsObj, ...parentColumnsObj }
+            if (currentAliasMap.parent.junctions) instanceWiki.junctions.push(...formatJunctions4InstanceWiki(findWiki.parent, is4UncalledJunctionPromise))
+            currentAliasMap = currentAliasMap.parent
+        }
+    }
+    instanceWiki.columns = instanceColumnsObj
+    return instanceWiki
+}
+
+
+function createNestedClassInstance(rowObj, instanceWiki, object4Nesting, entities, is4UncalledJunctionPromise) {
+    const currentAlias = instanceWiki.alias
+    const instanceId = is4UncalledJunctionPromise ? rowObj.id : rowObj[currentAlias + `_id`]
+    if (!instanceId) return
+
+    const currentClassName = instanceWiki.className
+
+    if (!object4Nesting[instanceId]) {
+        const target = object4Nesting[instanceId] = Object.create(entities[currentClassName].prototype)
+        for (const [propertyName, columnTypeObj] of Object.entries(instanceWiki.columns)) {
+            const val = rowObj[propertyName]
+            target[columnTypeObj.propertyName] = val
+        }
+    }
+
+    for (const junction of instanceWiki.junctions) {
+        const target = object4Nesting[instanceId][junction.propertyName] ??= {}
+        createNestedClassInstance(rowObj, junction, target, entities, is4UncalledJunctionPromise)
+    }
+}
+
+
+export function formatAndproxifyEntityInstanceObj(instance, findWiki, entities, /**@type {any}*/ proxyArr = undefined) {
+    const junctionEntries = Object.entries(findWiki.junctions ?? {})
+    for (const [junctionKey, junctionObj] of junctionEntries) {
+        if (junctionObj.isArray) {
+            instance[junctionKey] = Object.values(instance[junctionKey])
+            if (!instance[junctionKey]) continue
+            for (const joinedInstance of instance[junctionKey]) formatAndproxifyEntityInstanceObj(joinedInstance, junctionObj, entities)
+        }
+        else {
+            instance[junctionKey] = Object.values(instance[junctionKey])[0]
+            if (!instance[junctionKey]) continue
+            formatAndproxifyEntityInstanceObj(instance[junctionKey], junctionObj, entities)
+        }
+    }
+    const proxy = rowObj2InstanceProxy(instance, findWiki, entities)
+    if (proxyArr) proxyArr.push(proxy)
+}
+
+
+function formatColumns(aliasMap, is4UncalledJunctionPromise, /**@type {false | string}*/ rootChildAlias = false) {
+    const returnedObj = {}
+    let alias
+    if (rootChildAlias) alias = rootChildAlias
+    else alias = aliasMap.alias
+
+    const entries = Object.entries(aliasMap.columns)
+
+    if (is4UncalledJunctionPromise) {
+        for (const [propertyName, columnObj] of entries) {
+            columnObj.propertyName = propertyName
+            returnedObj[nonSnake2Snake(propertyName)] = columnObj
+        }
+    }
+    else {
+        for (const [propertyName, columnObj] of entries) {
+            columnObj.propertyName = propertyName
+            returnedObj[alias + `_${nonSnake2Snake(propertyName)}`] = columnObj
+        }
+    }
+    return returnedObj
+}
+
+
+function formatJunctions4InstanceWiki(aliasMap, is4UncalledJunctionPromise) {
+    const entries = Object.entries(aliasMap.junctions)
+    const returnedArr = []
+    for (const [propertyName, junctionObj] of entries) {
+        junctionObj.propertyName = propertyName
+        returnedArr.push(createInstanceWiki(junctionObj, is4UncalledJunctionPromise))
+    }
+    return returnedArr
+}
+
+export function sqliteDbValHandling(instance, propertyName, value, scopedMap) {
+    value = sqlite2JsTyping(value, findColumnObjOnWiki(propertyName, scopedMap))
+    const valType = Array.isArray(value) ? `array` : value instanceof Date ? `date` : typeof value
+    if (valType === `array`) {
+        const isArrayOfObjects = findColumnObjOnWiki(propertyName, scopedMap).type === `object`
+        instance[propertyName] = createNonRelationalArrayProxy(instance, propertyName, value.map(el => el === null ? undefined : el), undefined, isArrayOfObjects)
+    }
+    else if (valType === `object`) instance[propertyName] = createObjectProxy(instance, propertyName, value)
+    else instance[propertyName] = value
+}
+
+
+export function eagerLoadCTEsSqlite(findWiki, columnObj, cteArr = [], selectStatements = [], joinStatements = []) {
+    let cteStr = ``
+    let fromStatement = ``
+    const baseAlias = findWiki.alias
+    if (!cteArr.length) {
+        cteStr += `selected_cte AS ( SELECT ${baseAlias}.*, `
+        fromStatement += ` FROM root_cte ${baseAlias} `
+
+        const joinedTableArr = []
+        const joinedTableEntries = Object.entries(findWiki.junctions)
+
+        for (const [propertyName, joinedTableObj] of joinedTableEntries) {
+            selectStatements.push(`${joinedTableObj.alias}.*`)
+            joinStatements.push(junctionJoinSelectedCte(joinedTableObj, findWiki, propertyName, 'sqlite'))
+            joinedTableArr.push(joinedTableObj)
+        }
+
+        cteStr += selectStatements.join(`, `) + fromStatement + joinStatements.join(` `) + `)`
+        cteArr.push(cteStr)
+
+        for (const joinedTable of joinedTableArr) eagerLoadCTEsSqlite(joinedTable, columnObj, cteArr)
+    }
+    else {
+        cteStr += `${baseAlias}_cte AS (SELECT `
+        fromStatement += ` FROM ${nonSnake2Snake(findWiki.className)} ${baseAlias} `
+
+        const baseColumns = Object.values(columnObj[findWiki.className])
+        let columnNamingStr = baseColumns.map(columnName => `${baseAlias}.${columnName} AS ${baseAlias}_${columnName}`).join(`, `) + `, `
+        let joinStatements = []
+        if (findWiki.parent) {
+            let currentWiki = findWiki
+            while (currentWiki.parent) {
+                const parent = currentWiki.parent
+                const parentName = parent.className
+                const parentAlias = parent.alias
+
+                let parentColumnsArr = Object.values(columnObj[parentName])
+                const index = parentColumnsArr.indexOf(`id`)
+                parentColumnsArr.splice(index, 1)
+
+                columnNamingStr += parentColumnsArr.map(columnName => `${parentAlias}.${columnName} AS ${baseAlias}_${columnName}`).join(`, `) + `, `
+                joinStatements.push(parentJoin(parent, parentAlias, currentWiki))
+                currentWiki = currentWiki.parent
+            }
+        }
+
+        let selectedCtesArr = []
+        if (findWiki.junctions) {
+            const relationEntries = Object.entries(findWiki.junctions)
+            for (const [key, joinedTableObj] of relationEntries) {
+                joinStatements.push(junctionJoinCte(joinedTableObj, findWiki, key, 'sqlite'))
+                selectedCtesArr.push(`${joinedTableObj.alias}.*`)
+                eagerLoadCTEsSqlite(joinedTableObj, columnObj, cteArr)
+            }
+        }
+
+        cteStr += columnNamingStr.slice(0, -2) + ` `
+        if (selectedCtesArr.length) cteStr += `,` + selectedCtesArr.join(`, `)
+        cteStr += fromStatement + joinStatements.join(` `) + `)`
+        cteArr.unshift(cteStr)
+    }
+    return cteArr
+}

package/src/entity/find/where/relationalWhere.js

@@ -0,0 +1,142 @@
+import { Alias, aliasSymb } from "../../../misc/classes.js"
+import { nonSnake2Snake } from "../../../misc/miscFunctions.js"
+import { OrmStore } from "../../../misc/ormStore.js"
+import { proxyType, removeRelationFromUnusedRelations } from "../find.js"
+import { deproxifyScopeProxy, findPropOnScopeProxy, classWiki2ScopeObj } from "../scopeProxies.js"
+
+export function relationalWhereFuncs2Statements(mapObj, whereObj, queryStr = ``) {
+    const relationalWhereFunc = mapObj.relationalWhere
+    let AliasObj4func = createFullAndFlatAliasObj(mapObj)
+    const sqlWhereObj = relationalWhereFunc(AliasObj4func)
+    while (sqlWhereObj.params.length + sqlWhereObj.strings.length > 0) {
+        let paramIndex = whereObj.params.length + 1
+        if (sqlWhereObj.strings.length) queryStr += ` ` + sqlWhereObj.strings.shift()
+        if (sqlWhereObj.params.length) {
+            const param = sqlWhereObj.params.shift()
+            if (param instanceof Alias) {
+                if (param[aliasSymb] === `_InvalidPlaceholder_`) throw new Error(param.errMsg)
+                else queryStr += ` ` + param[aliasSymb]
+            }
+            else {
+                queryStr += ` $${paramIndex}`
+                whereObj.params.push(param)
+            }
+        }
+    }
+    queryStr = queryStr.trim().replaceAll("  ", " ")
+    whereObj.statements.push(queryStr)
+}
+
+
+function createFullAndFlatAliasObj(mapObj, fullFlatAliasObj = {}) {
+    const alias = mapObj.alias
+    const columnProperties = Object.keys(mapObj.columns)
+
+    for (const propertyName of columnProperties)
+        fullFlatAliasObj[propertyName] = new Alias(alias + `.` + nonSnake2Snake(propertyName))
+
+    if (mapObj.junctions) {
+        const relations = mapObj.junctions
+        const relationKeys = Object.keys(relations)
+        for (const key of relationKeys) {
+            const errMsg = `Invalid substitution in relational where - '${key}' is a substitution for a table, not a column.`
+            fullFlatAliasObj[key] = new Alias(`_InvalidPlaceholder_`, errMsg) //this isnt really needed, can be an object, but this guarantees an error
+            createFullAndFlatAliasObj(relations[key], fullFlatAliasObj[key])
+        }
+    }
+    if (mapObj.parent) createFullAndFlatAliasObj(mapObj.parent, fullFlatAliasObj)
+
+    return fullFlatAliasObj
+}
+
+export function mergeRelationalWhereScope(proxyMap, relationalWhereFunc) {
+    if (typeof relationalWhereFunc !== "function") throw new Error(`Relational where expects a function.`)
+    let mapObj = deproxifyScopeProxy(proxyMap)
+    const classWiki = OrmStore.store.classWikiDict[mapObj.className_]
+    const relationalWhereMapProxy = createRelationalWhereProxy(mapObj, classWiki)
+    relationalWhereFunc(relationalWhereMapProxy)
+    mapObj = deproxifyScopeProxy(relationalWhereMapProxy)
+    mapObj.relationalWhere_ = relationalWhereFunc
+    return reproxyMapObjPostRelationalWhere(mapObj, classWiki)
+}
+
+function reproxyMapObjPostRelationalWhere(mapObj, classWiki) {
+    if (mapObj.parent_) mapObj.parent_ = reproxyMapObjPostRelationalWhere(mapObj.parent_, classWiki.parent)
+
+    if (mapObj.junctions_) {
+        const mapRelations = mapObj.junctions_
+        for (const key of Object.keys(mapRelations))
+            mapRelations[key] = reproxyMapObjPostRelationalWhere(mapRelations[key], classWiki.junctions[key])
+    }
+
+    const proxy = new Proxy(mapObj, {
+        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 === "raw_") return target
+            else if (key === proxyType) return 'categorizingProxy'
+            else return findPropOnScopeProxy(target, key, classWiki.className)
+        },
+    })
+    return proxy
+}
+
+export function createRelationalWhereProxy(mapObj, classWiki) {
+    if (classWiki.parent) {
+        let parent
+        if (!mapObj.parent_) parent = classWiki2ScopeObj(classWiki)
+        else parent = mapObj.parent_
+        const parentOrmMap = classWiki.parent
+        mapObj.parent_ = createRelationalWhereProxy(parent, parentOrmMap)
+    }
+
+    if (mapObj.junctions_) {
+        const mapRelations = mapObj.junctions_
+        for (const key of Object.keys(mapRelations)) {
+            const relationOrmMap = classWiki.junctions[key]
+            mapRelations[key] = createRelationalWhereProxy(mapRelations[key], relationOrmMap)
+        }
+    }
+
+    const proxy = new Proxy(mapObj, {
+        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 === "raw_") return target
+            else if (key === proxyType) return 'relationalWhereProxy'
+            else return findPropOnRelationalWhereMapProxy(target, key, classWiki)
+        }
+    })
+    return proxy
+}
+
+export function findPropOnRelationalWhereMapProxy(mapObj, key, classWiki) {
+    if (mapObj.uncalledJunctions_[key]) {
+        const relation = mapObj.uncalledJunctions_[key]
+        const formattedRelationObj = classWiki2ScopeObj(relation)
+        removeRelationFromUnusedRelations(mapObj, key)
+        const proxyRelations = mapObj.junctions_ ??= {}
+        proxyRelations[key] = createRelationalWhereProxy(formattedRelationObj, classWiki.junctions[key])
+        return proxyRelations[key]
+    }
+    else if (mapObj.columns_[key]) return mapObj.columns_[key]
+    else if (mapObj.junctions_[key]) return mapObj.junctions_[key]
+    else if (mapObj.parent_) return findPropOnRelationalWhereMapProxy(mapObj.parent_, key, classWiki.parent)
+    else throw new Error(`\n'${key}' is not a valid property of class ${classWiki.className}. Please fix the find function's relationalWhere. \nhint: use intellisense by pressing CNTRL + space to see all viable options.`)
+}