masquerade-orm 0.8.1 → 0.8.3

package/src/misc/ormStore.js

@@ -12,7 +12,10 @@ export class OrmStore {
     }
 
     static getClassWiki(instanceClass) {
+        if (typeof instanceClass === 'string')
         return this.store.classWikiDict[instanceClass]
+
+        return this.store.classWikiDict[instanceClass.constructor.name]
     }
 }
 

package/src/misc/types.d.ts

@@ -204,7 +204,7 @@ type NonRelationsProperties<T> = Exclude<keyof T, RelationsProperties<T>>
 export type FindObj<T> = {
   relations?: Partial<RelationsOnly<T>>
   where?: WhereProperties<T>
-  relationalWhere?: sqlArrowFnTable<T> | (sqlArrowFn<T> | null)[] | null
+  templateWhere?: sqlArrowFnTable<T> | (sqlArrowFn<T> | null)[] | null
 }
 
 // ---------------------------------------------------------
@@ -455,7 +455,7 @@ type ArrColumnsRawParams =
 // export type FindObj<T> = {
 //   relations?: Partial<RelationsOnly<T>>
 //   where?: WhereProperties<T>
-//   relationalWhere?: sqlArrowFn<T> | sqlArrowFn<T>[]
+//   templateWhere?: sqlArrowFn<T> | sqlArrowFn<T>[]
 // }
 
 // // ---------------------------------------------------------

package/src/proxies/instanceProxy.js

@@ -65,8 +65,8 @@ export function rowObj2InstanceProxy(resultObj, findWiki, Entities) {
                 while (!currentWiki.uncalledJunctions[property]) currentWiki = currentWiki.parent
                 const uncalledJunctionObj = currentWiki.uncalledJunctions[property]
                 const nameOfMapWithJunction = uncalledJunctionObj.className
-                const promiseOf = uncalledJunctionObj.isArray ? nameOfMapWithJunction + `[]` : nameOfMapWithJunction
-                instance[property] = new LazyPromise(promiseOf)
+                const promiseType = uncalledJunctionObj.isArray ? nameOfMapWithJunction + `[]` : nameOfMapWithJunction
+                instance[property] = new LazyPromise(instance, property, promiseType, (resolve, reject) => promiseExecutor(instance, property, resolve, reject))
             }
         }
 
@@ -76,43 +76,57 @@ export function rowObj2InstanceProxy(resultObj, findWiki, Entities) {
     }
 }
 
-export function insertProxyIntoEntityMap(proxy, entityMap) {
-    entityMap.set(proxy.id, new WeakRef(proxy))
-    ORM[FinalizationRegistrySymb].register(proxy, [proxy.constructor.name, proxy.id])
-}
-
-export function instanceProxyGetHandler(target, key, classWiki) {
-    const val = target[key]
-    if (!(val instanceof LazyPromise)) return val
-
+function promiseExecutor(target, key, resolve, reject) {
+    if (ChangeLogger.scheduledFlush) ChangeLogger.save().then()
     const { sqlClient, dbConnection } = OrmStore.store
-    const [classification, joinedClassMap, mapWithProp] = getPropertyClassification(key, classWiki)
-    let joinedTable
-
-    if (classification === "Join") joinedTable = classWiki.junctions[key]
-    else joinedTable = mapWithProp.junctions[key]
-
-    const isArrayOfInstances = joinedClassMap.isArray
+    const classWiki = OrmStore.getClassWiki(target)
+    const [classification, joinedClassWiki, mapWithProp] = getPropertyClassification(key, classWiki)
+    const isArrayOfInstances = joinedClassWiki.isArray
 
     let queryStr = `SELECT entity.* FROM ${nonSnake2Snake(mapWithProp.className)}___${nonSnake2Snake(key)}_jt jt` +
-        ` LEFT JOIN ${nonSnake2Snake(joinedClassMap.className)} entity ON jt.joined_id = entity.id WHERE jt.joining_id = `
+        ` LEFT JOIN ${nonSnake2Snake(joinedClassWiki.className)} entity ON jt.joined_id = entity.id WHERE jt.joining_id = `
     queryStr += sqlClient === "postgresql" ? `$1` : `?`
 
     let queryFunc
     if (sqlClient === "postgresql") queryFunc = (queryStr, id) => dbConnection.query(queryStr, [id])
     else queryFunc = (queryStr, id) => dbConnection.prepare(queryStr).all(id)
 
-    let promise
     try {
-        let queryRes = queryFunc(queryStr, target.id)
-        promise = createLazyPromise(target, key, queryRes, mapWithProp.junctions[key], isArrayOfInstances, sqlClient)
-        promise.then(res => target[key] = res)
+        Promise.resolve(queryFunc(queryStr, target.id))
+            .then(rows => {
+                const { className, columns, junctions } = joinedClassWiki
+                const findWiki = { className, columns, uncalledJunctions: junctions }
+                let currentWiki = joinedClassWiki
+                let currentScopedMap = findWiki
+                while (currentWiki.parent) {
+                    const { className, columns, junctions } = currentWiki.parent
+                    currentScopedMap.parent = { className, columns, uncalledJunctions: junctions }
+                    currentScopedMap = currentScopedMap.parent
+                    currentWiki = currentWiki.parent
+                }
+
+                const proxyArr = []
+                for (const row of rows) {
+                    const rowWithCamelCasedProps = Object.fromEntries(Object.entries(row).map(([key, val]) => [snake2Pascal(key, true), val]))
+                    proxyArr.push(rowObj2InstanceProxy(rowWithCamelCasedProps, findWiki, OrmStore.store.entities))
+                }
+
+                if (isArrayOfInstances) target[key] = createRelationalArrayProxy(target, key, proxyArr, classWiki.className)
+                else target[key] = proxyArr[0]
+
+                resolve(target[key])
+            })
+            .catch(reject)
     }
-    catch (e) {
-        coloredBackgroundConsoleLog(`Lazy loading failed. ${e}\n`, `failure`)
+    catch (err) {
+        coloredBackgroundConsoleLog(`Lazy loading failed. ${err}`, 'failure')
+        reject(err)
     }
+}
 
-    return promise
+export function insertProxyIntoEntityMap(proxy, entityMap) {
+    entityMap.set(proxy.id, new WeakRef(proxy))
+    ORM[FinalizationRegistrySymb].register(proxy, [proxy.constructor.name, proxy.id])
 }
 
 export function instanceProxySetHandler(target, key, value, eventListenersObj, classWiki) {
@@ -356,57 +370,6 @@ export function createLazyLoadQueryStr(property, classWiki) {
 }
 
 
-export function createLazyPromise(target, key, queryRes, classWiki, isArrayOfInstances, client) {
-    return new Promise(async (resolve) => {
-        let resultArr
-        try {
-            if (client === "postgresql") resultArr = (await queryRes).rows
-            else resultArr = queryRes
-
-            if (!resultArr.length) {
-                if (isArrayOfInstances) {
-                    target[key] = []
-                    resolve([])
-                }
-                else {
-                    target[key] = undefined
-                    resolve(undefined)
-                }
-            }
-
-            const { className, columns, junctions } = classWiki
-            const findWiki = { className, columns, uncalledJunctions: junctions }
-            let currentWiki = classWiki
-            let currentScopedMap = findWiki
-            while (currentWiki.parent) {
-                const { className, columns, junctions } = currentWiki.parent
-                currentScopedMap.parent = { className, columns, uncalledJunctions: junctions }
-                currentScopedMap = currentScopedMap.parent
-                currentWiki = currentWiki.parent
-            }
-
-            const proxyArr = []
-            for (const row of resultArr) {
-                const rowWithCamelCasedProps = Object.fromEntries(Object.entries(row).map(([key, val]) => [snake2Pascal(key, true), val]))
-                proxyArr.push(rowObj2InstanceProxy(rowWithCamelCasedProps, findWiki, OrmStore.store.entities))
-            }
-
-            if (isArrayOfInstances) {
-                target[key] = createRelationalArrayProxy(target, key, proxyArr, classWiki.className)
-                resolve(target[key])
-            }
-            else {
-                target[key] = proxyArr[0]
-                resolve(target[key])
-            }
-        }
-        catch (e) {
-            coloredBackgroundConsoleLog(`Lazy loading failed. ${e}\n`, `failure`)
-        }
-    })
-}
-
-
 export function uncalledPropertySetHandler(target, key, value, columnClassificationArr) {
     const [propertyType, propertyTypeObj, mapWithProp] = columnClassificationArr
     const joiningId = target.id
@@ -496,7 +459,8 @@ export function proxifyEntityInstanceObj(instance, uncalledRelationalProperties)
             else if (key === "eEmitter_") return emitter
             else if (key === "eListener_") return eventListenersObj
             else if (key === "_isDeleted_") return target[key]
-            return instanceProxyGetHandler(target, key, classWiki)
+            return target[key]
+            //return instanceProxyGetHandler(target, key, classWiki)
         },
         set: (target, /**@type {string}*/ key, value) => {
             instanceProxySetHandler(target, key, value, eventListenersObj, classWiki)

package/src/webpack/masquerade-loader.js

@@ -1,14 +1,16 @@
-import { store } from "./store"
-import { createSourceFile, SyntaxKind, ScriptKind, ScriptTarget } from "typescript"
-
-
-export default function (source) {
-	const nodes = Object.values(source).map(source => createSourceFile('', source.toString(), ScriptTarget.Latest, true, ScriptKind.TSX).statements[0])
-	for (const node of nodes) {
-		//@ts-ignore
-		if ((node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression) && node.heritageClauses)
-					//@ts-ignore
-			store.nodeArr.push(node)
-	}
-	return source
-}
+import { store } from "./store.js"
+import { SyntaxKind } from "typescript"
+import ts from "typescript"
+
+export default function (source) {
+	const sourceFile = ts.createSourceFile("", source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+	const nodes = sourceFile.statements
+	for (const node of nodes) {
+		if (!node) continue
+		//@ts-ignore
+		const isValid = (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression) && node.heritageClauses
+		//@ts-ignore
+		if (isValid) store.nodeArr.push(node)
+	}
+	return source
+}

package/src/webpack/plugin.js

@@ -1,43 +1,42 @@
-
-import { store } from "./store.js"
-
-import { nodeArr2ClassDict } from "../ORM/bootOrm.js"
-
-export class MasqueradePlugin {
-  apply(compiler) {
-    compiler.hooks.compilation.tap(this.constructor.name, (compilation) => {
-      compilation.hooks.processAssets.tap(
-        {
-          name: this.constructor.name,
-          stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONS,
-        },
-        (assets) => {
-          const classDict = nodeArr2ClassDict(store.nodeArr)
-          const prefix = `globalThis.masqueradeClassDict_ = ${JSON.stringify(classDict)};\n`
-
-          for (const entry of compilation.entrypoints.values()) {
-            for (const file of entry.getFiles()) {
-              if (!file.endsWith(".js")) continue
-
-              const asset = compilation.getAsset(file)
-              const source = asset.source.source()
-
-              compilation.updateAsset(
-                file,
-                new compiler.webpack.sources.RawSource(prefix + source)
-              )
-            }
-          }
-        }
-      )
-    })
-  }
-}
-
-
-
-
-
-
-
-
+
+import { store } from "./store.js"
+import { nodeArr2ClassDict } from "../ORM/bootOrm.js"
+
+export class MasqueradePlugin {
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.constructor.name, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        {
+          name: this.constructor.name,
+          stage: compilation.constructor.PROCESS_ASSETS_STAGE_ADDITIONS,
+        },
+        (assets) => {
+          const classDict = nodeArr2ClassDict(store.nodeArr)
+          const prefix = `globalThis.masqueradeClassDict_ = ${JSON.stringify(classDict)};\n`
+
+          for (const entry of compilation.entrypoints.values()) {
+            for (const file of entry.getFiles()) {
+              if (!file.endsWith(".js")) continue
+
+              const asset = compilation.getAsset(file)
+              const source = asset.source.source()
+
+              compilation.updateAsset(
+                file,
+                new compiler.webpack.sources.RawSource(prefix + source)
+              )
+            }
+          }
+        }
+      )
+    })
+  }
+}
+
+
+
+
+
+
+
+

package/testing/postgres.test.js

@@ -3,14 +3,14 @@ import test from 'node:test'
 import assert from "node:assert"
 import * as classes from './testing-classes.js'
 import { resetPostgresDb, initORM, createConfigObj } from "./testInit.js"
-import { sql } from '..//src/entity/find/where/whereArgsFunctions.js'
+import { sql } from '../src/entity/find/where/whereArgsFunctions.js'
 import { generateFamiliesAndHouses } from "./generationFuncs.js"
 import { validateUpdatedAt } from "./miscFunctions.js"
 import { OrmStore } from '../src/misc/ormStore.js'
 
 const { House, Person, NonRelationalClass2 } = classes
 
-const configObj = createConfigObj()
+const configObj = createConfigObj('postgres', '123456789')
 await resetPostgresDb(configObj.dbConnection)
 await initORM(configObj, classes)
 let dbChanges = OrmStore.store.dbChangesObj

package/testing/sqlite.test.js

@@ -3,7 +3,7 @@ import test from 'node:test'
 import assert from "node:assert"
 import * as classes from './testing-classes.js'
 import { initORM, createConfigObj } from "./testInit.js"
-import { sql } from '..//src/entity/find/where/whereArgsFunctions.js'
+import { sql } from '../src/entity/find/where/whereArgsFunctions.js'
 import { generateFamiliesAndHouses } from "./generationFuncs.js"
 import { validateUpdatedAt } from "./miscFunctions.js"
 import { OrmStore } from '../src/misc/ormStore.js'
@@ -254,4 +254,3 @@ test.after(async () => {
     await fs.rm("./test", { force: true })
     console.log('db reset')
 })
-

package/testing/testInit.js

@@ -0,0 +1,34 @@
+import { ORM } from "../index.js"
+import { DatabaseSync } from 'node:sqlite'
+import { Pool } from 'pg'
+/**@typedef {import('../index.js').OrmConfigObj} OrmConfigObj */
+
+
+export function createConfigObj(client, /**@type {undefined | string}*/ dbPaswword = undefined) {
+    if (client === `sqlite`) return {
+        dbConnection: new DatabaseSync('test'),
+        idTypeDefault: "INT"
+    }
+
+    return {
+        dbConnection: new Pool({
+            user: 'postgres',                   // e.g., 'postgres'
+            host: 'localhost',                 // database host
+            database: 'masquerade-test',      // database name
+            password: `${dbPaswword}`,           // your password
+            port: 5432,                     // default PostgreSQL port
+        }),
+        idTypeDefault: "INT"
+    }
+}
+
+export async function initORM(configObj, ...classes) {
+    await ORM.javascriptBoot(configObj, ...classes)
+}
+
+export async function resetPostgresDb(pool) {
+    await pool.query(
+        `DROP SCHEMA public CASCADE;
+        CREATE SCHEMA public;`
+    )
+}

package/testing/testing-classes.js

@@ -1,6 +1,6 @@
-import { Entity } from 'masquerade'
+import { Entity } from '../index.js'
 import { jsonGenerator } from './miscFunctions.js'
-/**@typedef {import('masquerade').integer} integer */
+/**@typedef {import('../index.js').integer} integer */
 
 
 export class House extends Entity {