masquerade-orm 0.1.0

package/src/proxies/relationalArrayProxy.js

@@ -0,0 +1,130 @@
+import { ChangeLogger } from "../changeLogger/changeLogger.js"
+import { getValidTypedArray } from "../misc/miscFunctions.js"
+import { OrmStore } from "../misc/ormStore.js"
+import { setUpdatedAtValue } from "./instanceProxy.js"
+
+
+export function createRelationalArrayProxy(instance, propertyName, array = [], /**@type {string | undefined}*/ arrElementValidType = undefined) {
+    const instanceId = instance.id
+    const instanceClass = instance.constructor.name
+    const classChangeObj = OrmStore.getClassChangesObj(instanceClass)
+    const eventListenersObj = {}
+    //if arrElementValidType is undefined, it just means that the array we are proxifying is an array we got from the db, so the typing is correct.
+    if (arrElementValidType) array = getValidTypedArray(array, arrElementValidType, true)
+    array.forEach(proxy => addEventListener2ArrayProxy(proxy, array, eventListenersObj, instance.id, propertyName, instanceClass))
+
+    return new Proxy(array, {
+        //ARRAY PROXIES ARE FOR RELATIONAL X:N
+        get(target, key, receiver) {
+            if (key === "source_") return target
+            else if (key === "eListener_") return eventListenersObj
+            else {
+                if (key === "includes") return (instance) => {
+                    //@ts-ignore
+                    if (eventListenersObj[instance.id]) return true
+                    return false
+                }
+                return target[key]
+            }
+        },
+        set(/**@type {any[]}*/ target, key, value, receiver) {
+            if (key === "length") return Reflect.set(target, key, value, receiver)
+            return relationalArrayProxySetHandler(target, key, value, propertyName, instanceId, eventListenersObj, instanceClass)
+        },
+        deleteProperty(target, key) {
+            return relationalArrayProxyDeleteHandler(target, key, propertyName, instanceId, eventListenersObj, instanceClass)
+        }
+    })
+}
+
+
+export function relationalArrayProxySetHandler(target, key, newInstanceProxy, propertyName, instanceId, eventListenersObj, instanceClass) {
+    const index = parseInt(key)
+    if (index > -1) {
+        const oldInstanceProxy = target[index]
+        const classChangeObj = OrmStore.getClassChangesObj(instanceClass)
+        const instanceChangesObj = classChangeObj[instanceId] ??= {}
+
+        if (eventListenersObj[newInstanceProxy.id]) throw new Error(`Do not insert duplicate entity instances into a relational array. Use the 'includes' method for O(1) lookup.`)
+        const relationChangeLogger = instanceChangesObj[propertyName] ??= { added: [], removed: [] }
+
+        if (oldInstanceProxy) {
+            const oldValueInAdded = relationChangeLogger.added.indexOf(oldInstanceProxy.id)
+            if (oldValueInAdded > -1) relationChangeLogger.added.splice(oldValueInAdded, 1)
+            else relationChangeLogger.removed.push(oldInstanceProxy.id)
+
+            const oldProxyEventEmitter = oldInstanceProxy.eEmitter_
+            oldProxyEventEmitter.removeEventListener("delete", eventListenersObj[oldInstanceProxy.id])
+            delete eventListenersObj[oldInstanceProxy.id]
+        }
+        const newValueInRemoved = relationChangeLogger.removed.indexOf(newInstanceProxy.id)
+        if (newValueInRemoved > -1) relationChangeLogger.removed.splice(newValueInRemoved, 1)
+        else relationChangeLogger.added.push(newInstanceProxy.id)
+
+        target[index] = newInstanceProxy
+        addEventListener2ArrayProxy(newInstanceProxy, target, eventListenersObj, instanceId, propertyName, instanceClass)
+        setUpdatedAtValue(target, instanceChangesObj)
+        return true
+    }
+    else if (typeof index === `string` || typeof index === `symbol`) {
+        target[index] = newInstanceProxy
+        return true
+    }
+    return false
+}
+
+export function relationalArrayProxyDeleteHandler(target, key, propertyName, instanceId, eventListenersObj, instanceClass) {
+    const validProp = Object.hasOwn(target, key)
+    const deletedArrEl = target[key]
+
+    if (validProp) {
+        //@ts-ignore
+        const index = parseInt(key)
+        if (index > -1) {
+            const classChangeObj = OrmStore.getClassChangesObj(instanceClass)
+            const instanceChangesObj = classChangeObj[instanceId] ??= {}
+            const removedEventFunc = eventListenersObj[deletedArrEl.id]
+            deletedArrEl.eEmitter_.removeEventListener("delete", removedEventFunc)
+            logRelationalArrayRemoval(target, propertyName, deletedArrEl.id, instanceChangesObj)
+        }
+        delete target[key]
+        return true
+    }
+    return false
+}
+
+export function logRelationalArrayRemoval(instance, propertyName, removedId, instanceChangesObj) {
+    if (!instanceChangesObj[propertyName]) {
+        instanceChangesObj[propertyName] = { added: [], removed: [removedId] }
+    }
+    else {
+        const relationalArrChangeLogger = instanceChangesObj[propertyName]
+        const oldIndex = relationalArrChangeLogger.added.indexOf(removedId)
+        if (oldIndex > -1) relationalArrChangeLogger.added.splice(oldIndex, 1)
+        else relationalArrChangeLogger.removed.push(removedId)
+    }
+    setUpdatedAtValue(instance, instanceChangesObj)
+}
+
+export function addEventListener2ArrayProxy(proxy, array, eventListenersObj, idOfInstanceWithArray, propertyOfArray, instanceClass) {
+    const emitter = proxy.eEmitter_
+    const eventFunc = (event) => {
+        if (proxy._isDeleted_) return
+        const id2delete = event.detail.id
+        // console.log(`Delete event sent from ${id2delete}_${proxy.constructor.name} to proxy array`)
+        const index = array.findIndex(proxy => proxy.id === id2delete)
+        array.splice(index, 1)
+        delete eventListenersObj[id2delete]
+        const classChangeObj = OrmStore.getClassChangesObj(instanceClass)
+        const instanceChangesObj = classChangeObj[idOfInstanceWithArray] ??= {}
+        logRelationalArrayRemoval(proxy, propertyOfArray, id2delete, instanceChangesObj)
+    }
+
+    emitter.addEventListener(
+        "delete",
+        eventFunc,
+        { once: true }
+    )
+
+    eventListenersObj[proxy.id] = eventFunc
+}

package/src/webpack/masquerade-loader.js

@@ -0,0 +1,14 @@
+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
+}

package/src/webpack/plugin.js

@@ -0,0 +1,43 @@
+
+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/src/webpack/store.js

@@ -0,0 +1,2 @@
+const store = { classArr:[], nodeArr:[], ormSettings:[] }
+export {store}

package/src/webpack/webpack.config.js

@@ -0,0 +1,41 @@
+import path from 'path'
+import { MasqueradePlugin } from './plugin.js'
+
+
+export default {
+    mode: 'development',
+    target: 'node',
+    entry: './src/project.ts',
+    devtool: 'source-map',
+    plugins: [
+        //other plugins...
+        new MasqueradePlugin() //this should be last
+    ],
+    module: {
+        rules: [
+            {
+                test: /\.tsx?$/,
+                use: ['ts-loader', 'masquerade-loader'],
+                exclude: /node_modules/,
+            },
+        ],
+    },
+    resolve: {
+        extensions: ['.tsx', '.ts', '.js'],
+    },
+    output: {
+        filename: 'bundle.js',
+        devtoolModuleFilenameTemplate: '[absolute-resource-path]', // Helps VS Code find original files
+        path: path.resolve(import.meta.dirname, 'dist'),
+        library: {
+            type: "module"
+        }
+    },
+    experiments: {
+        outputModule: true
+    },
+    resolveLoader: {
+        modules: ["node_modules", path.resolve(import.meta.dirname, 'loaders')]
+    }
+
+};

package/testing/dev-doc.md

@@ -0,0 +1,7 @@
+# SQL Client Differences
+- major differences in the find (postgres gives back a nested object, while sqlite is flat and manually nested)
+- slight differences in the save
+- slight differences in type mapping
+
+anything internal (proxies and their state management data structures) is agnostic to sql clients.
+

package/testing/generationFuncs.js

@@ -0,0 +1,21 @@
+import { familyAgeGenerator, familyNameGenerator } from "./miscFunctions.js"
+import { Person, House } from "./testing-classes.js"
+
+export function generateFamiliesAndHouses() {
+    for (let i = 0; i < 30; i++) {
+        const familySize = 3 + Math.floor(Math.random() * 7)
+        const [fatherName, motherName, ...childrenNames] = familyNameGenerator(familySize)
+        const [fatherAge, motherAge, ...childrenAges] = familyAgeGenerator(familySize)
+
+        const father = new Person(fatherName, fatherAge)
+        const mother = new Person(motherName, motherAge)
+        const children = []
+        for (const i in childrenNames) {
+            const child = new Person(childrenNames[i], childrenAges[i], father, mother)
+            children.push(child)
+        }
+        father.children.push(...children)
+        mother.children.push(...children)
+        new House(father, [father, mother, ...children])
+    }
+}

package/testing/miscFunctions.js

@@ -0,0 +1,97 @@
+export function jsonGenerator() {
+    return {
+        booleanField: true,
+        floatVal: 15.7,
+        someInt: 5,
+        stringArr: ['a', 'b', 'c']
+    }
+}
+
+const nameArrMale = [
+    "James",
+    "John",
+    "Robert",
+    "Michael",
+    "William",
+    "David",
+    "Richard",
+    "Joseph",
+    "Charles",
+    "Thomas",
+    "Daniel",
+    "Matthew",
+    "Anthony",
+    "Mark",
+    "Paul",
+    "Steven",
+    "Andrew",
+    "Kenneth",
+    "Joshua",
+    "Kevin"
+]
+
+const nameArrFemale = [
+    "Mary",
+    "Patricia",
+    "Jennifer",
+    "Linda",
+    "Elizabeth",
+    "Barbara",
+    "Susan",
+    "Jessica",
+    "Sarah",
+    "Karen",
+    "Nancy",
+    "Lisa",
+    "Margaret",
+    "Betty",
+    "Sandra",
+    "Ashley",
+    "Kimberly",
+    "Emily",
+    "Donna",
+    "Michelle"
+]
+
+const surnames = [
+    "Smith",
+    "Johnson",
+    "Williams",
+    "Brown",
+    "Jones",
+    "Garcia",
+    "Miller",
+    "Davis",
+    "Rodriguez",
+    "Martinez"
+]
+
+export function arrayRandomPick(array) {
+    return array[Math.floor(Math.random() * array.length)]
+}
+
+export function familyNameGenerator(/**@type {number}*/ familySize) {
+    const familyNames = []
+    let firstName = arrayRandomPick(nameArrMale)
+    const surname = arrayRandomPick(surnames)
+    familyNames.push(`${firstName} ${surname}`)
+    firstName = arrayRandomPick(nameArrFemale)
+    familyNames.push(`${firstName} ${surname}`)
+
+    const childrenFirstNames = [...nameArrMale, ...nameArrFemale]
+    for (let i = 0; i < familySize - 2; i++) familyNames.push(`${arrayRandomPick(childrenFirstNames)} ${surname}`)
+    return familyNames
+}
+
+export function familyAgeGenerator(/**@type {number}*/ familySize) {
+    const fatherAge = 18 + Math.floor(Math.random() * 20)
+    const motherAge = 18 + Math.floor(Math.random() * 20)
+    const familyAges = [fatherAge, motherAge]
+    for (let i = 0; i < familySize - 2; i++) familyAges.push(1 + Math.floor(Math.random() * (Math.min(motherAge, fatherAge) - 18)))
+    return familyAges
+}
+
+export function validateUpdatedAt(updatedAt, currentTime) {
+    return updatedAt.getTime() - currentTime.getTime() >= 0
+}
+

package/testing/postgres.test.js

@@ -0,0 +1,254 @@
+
+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 { generateFamiliesAndHouses } from "./generationFuncs.js"
+import { validateUpdatedAt } from "./miscFunctions.js"
+import { OrmStore } from '../src/misc/ormStore.js'
+
+const { House, Person, NonRelationalClass2 } = classes
+
+const configObj = createConfigObj()
+await resetPostgresDb(configObj.dbConnection)
+await initORM(configObj, classes)
+let dbChanges = OrmStore.store.dbChangesObj
+generateFamiliesAndHouses()
+for (let i = 0; i < 3; i++) new NonRelationalClass2()
+
+const nonRelationalTest = await NonRelationalClass2.find({ where: { json: sql`->>'someInt' = '5'` } })
+test('test 1 - find basics and change logging', async (t) => {
+
+  await t.test('find basics', async (t) => {
+
+    await t.test('find result length is correct', async () => {
+      assert.strictEqual(nonRelationalTest.length, 3)
+    })
+
+    await t.test('find returns correct typing', async () => {
+      assert.strictEqual(typeof nonRelationalTest[0].bigint, 'bigint')
+      assert.strictEqual(typeof nonRelationalTest[0].boolean, 'boolean')
+      assert.strictEqual(typeof nonRelationalTest[0].stringArr[0], 'string')
+      assert.strictEqual(typeof nonRelationalTest[0].id, 'number')
+      assert.strictEqual(typeof nonRelationalTest[0].json, 'object')
+      assert.strictEqual(typeof nonRelationalTest[0].jsonArr[0], 'object')
+      assert.ok(Array.isArray(nonRelationalTest[0].stringArr))
+      assert.ok(Array.isArray(nonRelationalTest[0].jsonArr))
+    })
+  })
+
+  await t.test('assignments and dbChanges', async (t) => {
+    const typeTestId = nonRelationalTest[0].id.toString()
+    nonRelationalTest[0].int = 157
+
+    const testInstanceChangeLog = dbChanges.NonRelationalClass2[typeTestId]
+
+    /** @type {any} */
+    let expectedVal = {
+      booleanField: false,
+      floatVal: 12.33,
+      someInt: 7,
+      stringArr: ['masquerade', 'orm', 'best', 'orm'],
+      unstructuredData: 'random data'
+    }
+
+    let currentTime
+
+    await t.test('non-relational non-arrays', async () => {
+      currentTime = new Date()
+      nonRelationalTest[0].boolean = false
+
+      assert.strictEqual(testInstanceChangeLog.boolean, false)
+      assert.strictEqual(validateUpdatedAt(testInstanceChangeLog.updatedAt, currentTime), true)
+
+      currentTime = new Date()
+      nonRelationalTest[0].json = {
+        booleanField: false,
+        floatVal: 12.33,
+        someInt: 7,
+        stringArr: ['masquerade', 'orm']
+      }
+
+      nonRelationalTest[0].json.unstructuredData = 'random data'
+      nonRelationalTest[0].json.stringArr.push('best', 'orm')
+
+      assert.deepStrictEqual(testInstanceChangeLog.json, expectedVal)
+      assert.strictEqual(validateUpdatedAt(testInstanceChangeLog.updatedAt, currentTime), true)
+    })
+
+    await t.test('non-relational arrays', async () => {
+      currentTime = new Date()
+      nonRelationalTest[0].stringArr = ['good', 'day']
+      nonRelationalTest[0].stringArr.push('sir')
+
+      assert.deepStrictEqual(testInstanceChangeLog.stringArr, ['good', 'day', 'sir'])
+      assert.strictEqual(validateUpdatedAt(testInstanceChangeLog.updatedAt, currentTime), true)
+
+      currentTime = new Date()
+      nonRelationalTest[0].jsonArr.push({
+        someInt: 7,
+        booleanField: false,
+        floatVal: 7.7,
+        stringArr: ['hola', 'mundo']
+      })
+
+      expectedVal =
+        '[{"booleanField":true,"floatVal":15.7,"someInt":5,"stringArr":["a","b","c"]},{"someInt":7,"booleanField":false,"floatVal":7.7,"stringArr":["hola","mundo"]}]'
+
+      assert.deepStrictEqual(testInstanceChangeLog.jsonArr, expectedVal)
+      assert.strictEqual(validateUpdatedAt(testInstanceChangeLog.updatedAt, currentTime), true)
+
+      currentTime = new Date()
+      nonRelationalTest[0].jsonArr[0].stringArr = ['someString']
+
+      expectedVal =
+        '[{"booleanField":true,"floatVal":15.7,"someInt":5,"stringArr":["someString"]},{"someInt":7,"booleanField":false,"floatVal":7.7,"stringArr":["hola","mundo"]}]'
+
+      assert.deepStrictEqual(testInstanceChangeLog.jsonArr, expectedVal)
+      assert.strictEqual(validateUpdatedAt(testInstanceChangeLog.updatedAt, currentTime), true)
+    })
+  })
+
+  let undefinedTest = await House.find({ relations: { owner: true, tenants: true } })
+
+  const lastHouse = undefinedTest[undefinedTest.length - 1]
+  lastHouse.owner = undefined
+  lastHouse.tenants = undefined
+
+  undefinedTest = await House.find({
+    where: { id: lastHouse.id },
+    relations: { owner: true, tenants: true }
+  })
+
+  await t.test('assigning undefined values to relational props', async () => {
+    assert.strictEqual(undefinedTest[0].owner, undefined)
+    assert.deepStrictEqual(undefinedTest[0].tenants, [])
+  })
+
+  await t.test('presave new instances', async (t) => {
+    await t.test('new instance proxies communicate with dbChanges correctly', async () => {
+      const preSaveChanges = new NonRelationalClass2()
+      preSaveChanges.stringArr.push('please rewrite this in rust')
+      preSaveChanges.bigint = 12n
+
+      const preSaveChangesObj =
+        dbChanges.NonRelationalClass2[preSaveChanges.id.toString()]
+
+      assert.deepStrictEqual(
+        preSaveChangesObj.stringArr,
+        ['hello', 'world', 'please rewrite this in rust']
+      )
+      assert.deepStrictEqual(preSaveChangesObj.bigint, 12n)
+    })
+  })
+})
+
+
+test('test 2 - promises and instance logging', async (t) => {
+
+  await t.test('overwriting promises without loading', async (t) => {
+    let firstRelationalTest = (await House.find({ where: { id: 1 } }))[0]
+    const mrClean = (firstRelationalTest.owner = new Person('Mr Clean', 30))
+    firstRelationalTest.tenants = [mrClean, new Person('Mrs Clean', 24)]
+
+    firstRelationalTest = (await House.find({ where: { id: 1 } }))[0]
+    await initORM(configObj, classes)
+
+    firstRelationalTest = (
+      await House.find({
+        where: { id: 1 },
+        relations: { owner: true, tenants: true }
+      })
+    )[0]
+
+    await t.test('1-to-1 relational promise assignment', async () => {
+      assert.strictEqual(firstRelationalTest?.owner?.fullName, 'Mr Clean')
+    })
+
+    await t.test('1-to-many relational promise assignment', async () => {
+      assert.strictEqual(firstRelationalTest?.tenants?.length, 2)
+      assert.strictEqual(firstRelationalTest.tenants[0].fullName, 'Mr Clean')
+      assert.strictEqual(firstRelationalTest.tenants[1].fullName, 'Mrs Clean')
+    })
+  })
+
+  await t.test('check instance logging', async (t) => {
+    const original = (
+      await House.find({
+        where: { id: 2 },
+        relations: { owner: true, tenants: true }
+      })
+    )[0]
+
+    const sameInstance = (await House.find({ where: { id: 2 } }))[0]
+
+    await t.test('instance logging is working correctly', async () => {
+      assert.strictEqual(original === sameInstance, true)
+    })
+  })
+})
+
+test('test 3 - deletion', async (t) => {
+  let house = (await House.find({
+    relations:
+    {
+      owner:
+        { children: true },
+      tenants:
+      {
+        father: true,
+        mother: true
+      }
+    },
+    where: { id: 5 }
+  }))[0]
+
+  const father = house.owner
+  const childrenCount = father?.children.length
+  const tenantCount = house.tenants?.length
+  //@ts-ignore
+  let children = [...father?.children]
+  const firstChild = children.shift()
+
+  await t.test('deletion events - relational arrays', async () => {
+    await firstChild.delete()
+    //@ts-ignore
+    assert.strictEqual(childrenCount - father?.children.length === 1, true)
+    assert.strictEqual(father?.children.includes(firstChild), false)
+  })
+
+  await t.test('deletion events - 1-to-1 relation', async () => {
+    await father?.delete()
+    await House.find({})
+    await initORM(configObj, classes)
+
+    house = (await House.find({
+      relations:
+      {
+        owner:
+          { children: true },
+        tenants:
+        {
+          father: true,
+          mother: true,
+          children: true
+        }
+      },
+      where: { id: 5 }
+    }))[0]
+
+    const childrenIds = children.map(child => child.id)
+    house.tenants && tenantCount && assert.strictEqual(tenantCount - house.tenants?.length, 2)
+    assert.strictEqual(childrenIds.includes(firstChild.id), false)
+    for (const person of house.tenants ?? []) assert.strictEqual(person.father, undefined)
+  })
+})
+
+test.after(async () => {
+  await resetPostgresDb(configObj.dbConnection)
+  console.log('db reset')
+  // @ts-ignore
+  configObj.dbConnection.end()
+})
+