@cheetah.js/orm 0.1.62 → 0.1.64

package/dist/SqlBuilder.js

@@ -285,9 +285,10 @@ class SqlBuilder {
         }
     }
     setDefaultValue(values, key, property) {
-        if (typeof values[key] !== 'undefined')
+        const columnName = property.options.columnName;
+        if (typeof values[columnName] !== 'undefined')
             return;
-        values[key] = typeof property.options.default === 'function'
+        values[columnName] = typeof property.options.default === 'function'
             ? property.options.default()
             : property.options.default;
     }
@@ -296,8 +297,9 @@ class SqlBuilder {
         properties.forEach(([key, property]) => this.applyOnInsert(values, key, property));
     }
     applyOnInsert(values, key, property) {
-        values[key] = property.options.onInsert();
-        this.updatedColumns.push(`${this.statements.alias}."${key}" as "${this.statements.alias}_${key}"`);
+        const columnName = property.options.columnName;
+        values[columnName] = property.options.onInsert();
+        this.updatedColumns.push(`${this.statements.alias}."${columnName}" as "${this.statements.alias}_${columnName}"`);
     }
     withUpdatedValues(values, entityOptions) {
         const properties = Object.entries(entityOptions.properties).filter(([_, value]) => value.options.onUpdate);

package/dist/orm.service.js

@@ -237,22 +237,43 @@ let OrmService = class OrmService {
         });
     }
     async onInit(customConfig = {}) {
-        const configFile = globby.sync('cheetah.config.ts', { absolute: true });
-        if (configFile.length === 0) {
-            console.log('No config file found!');
-            return;
+        const hasCustomConfig = Object.keys(customConfig).length > 0;
+        let config = null;
+        let setConfig;
+        if (!hasCustomConfig) {
+            const configFile = globby.sync('cheetah.config.ts', { absolute: true });
+            if (configFile.length === 0) {
+                console.log('No config file found!');
+                return;
+            }
+            config = await Promise.resolve(`${configFile[0]}`).then(s => __importStar(require(s)));
+            setConfig = config.default;
+        }
+        else {
+            setConfig = customConfig;
         }
-        const config = await Promise.resolve(`${configFile[0]}`).then(s => __importStar(require(s)));
-        const setConfig = Object.keys(customConfig).length > 0 ? customConfig : config.default;
         this.orm.setConnection(setConfig);
         await this.orm.connect();
-        if (typeof config.default.entities === 'string') {
+        if (config && typeof config.default.entities === 'string') {
             const files = globby.sync([config.default.entities, '!node_modules'], { gitignore: true, absolute: true });
             for (const file of files) {
                 await Promise.resolve(`${file}`).then(s => __importStar(require(s)));
             }
         }
-        const entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect);
+        let entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect);
+        if (!entities) {
+            const entityPaths = this.getSourceFilePaths();
+            const entityFiles = globby.sync(entityPaths.filter(path => path.includes('.entity.') || path.includes('entities/')));
+            for (const file of entityFiles) {
+                try {
+                    await Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+                }
+                catch (error) {
+                    console.warn(`Failed to import entity file ${file}:`, error);
+                }
+            }
+            entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect);
+        }
         if (!entities) {
             console.log('No entities found!');
             return;

package/dist/query/model-transformer.d.ts

@@ -18,4 +18,5 @@ export declare class ModelTransformer {
     private findRelationProperty;
     private attachJoinedEntity;
     private appendToArray;
+    private resetChangedValues;
 }

package/dist/query/model-transformer.js

@@ -12,6 +12,7 @@ class ModelTransformer {
         const optionsMap = this.buildOptionsMap(instanceMap);
         this.populateProperties(data, instanceMap, optionsMap);
         this.linkJoinedEntities(statement, instanceMap, optionsMap);
+        this.resetChangedValues(instanceMap);
         return instanceMap[statement.alias];
     }
     createInstances(model, statement) {
@@ -118,5 +119,17 @@ class ModelTransformer {
     appendToArray(existingArray, newItem) {
         return existingArray ? [...existingArray, newItem] : [newItem];
     }
+    resetChangedValues(instanceMap) {
+        Object.values(instanceMap).forEach(instance => {
+            const currentValues = {};
+            for (const key in instance) {
+                if (!key.startsWith('_') && !key.startsWith('$')) {
+                    currentValues[key] = instance[key];
+                }
+            }
+            instance._oldValues = currentValues;
+            instance._changedValues = {};
+        });
+    }
 }
 exports.ModelTransformer = ModelTransformer;

package/dist/testing/with-database.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -21,12 +54,37 @@ const DEFAULT_CONNECTION = {
     password: 'postgres',
     driver: bun_pg_driver_1.BunPgDriver,
 };
+const sessionCache = new Map();
+function getCacheKey(options) {
+    const connection = resolveConnection(options.connection);
+    return JSON.stringify({
+        host: connection.host,
+        port: connection.port,
+        database: connection.database,
+        schema: options.schema ?? DEFAULT_SCHEMA,
+        entityFile: options.entityFile,
+        migrationPath: connection.migrationPath,
+    });
+}
 async function withDatabase(arg1, arg2, arg3) {
     const { routine: targetRoutine, options: targetOptions, statements } = await normalizeArgs(arg1, arg2, arg3);
-    const session = await createSession(targetOptions);
-    const context = buildContext(session.orm);
+    const cacheKey = getCacheKey(targetOptions);
+    let cachedSession = sessionCache.get(cacheKey);
     const schemaStatements = await resolveSchemaStatements(statements, targetOptions);
-    await executeWithinSession(session, context, schemaStatements, targetRoutine);
+    if (!cachedSession) {
+        const session = await createSession(targetOptions);
+        cachedSession = {
+            orm: session.orm,
+            tables: [],
+            schema: session.schema,
+        };
+        sessionCache.set(cacheKey, cachedSession);
+    }
+    const context = buildContext(cachedSession.orm);
+    await dropAndRecreateSchema(context, cachedSession.schema);
+    await prepareSchema(context, cachedSession.schema);
+    await createTables(context, schemaStatements);
+    await targetRoutine(context);
 }
 async function createSession(options) {
     const logger = selectLogger(options);
@@ -43,6 +101,12 @@ function selectLogger(options) {
 }
 async function initializeOrm(orm, options) {
     const storage = new entities_1.EntityStorage();
+    if (options.entityFile) {
+        const entityFiles = await (0, globby_1.default)(options.entityFile, { absolute: true });
+        for (const file of entityFiles) {
+            await Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+        }
+    }
     const service = new orm_service_1.OrmService(orm, storage, options.entityFile);
     const connection = resolveConnection(options.connection);
     await service.onInit(connection);
@@ -70,16 +134,6 @@ async function executeSql(orm, sql) {
     const result = await orm.driverInstance.executeSql(sql);
     return { rows: Array.isArray(result) ? result : [] };
 }
-async function executeWithinSession(session, context, statements, routine) {
-    try {
-        await prepareSchema(context, session.schema);
-        await createTables(context, statements);
-        await routine(context);
-    }
-    finally {
-        await resetSession(session, context);
-    }
-}
 async function createTables(context, statements) {
     const payload = statements.filter(Boolean);
     if (payload.length < 1) {
@@ -92,17 +146,8 @@ async function executeStatements(context, statements) {
         await context.executeSql(statement);
     }
 }
-async function resetSession(session, context) {
-    await dropSchema(session, context);
-    await ensureSearchPath(context, session.schema);
-    await session.orm.disconnect();
-}
-async function dropSchema(session, context) {
-    const statement = buildDropStatement(session.schema);
-    await context.executeSql(statement);
-}
-function buildDropStatement(schema) {
-    return `DROP SCHEMA IF EXISTS ${schema} CASCADE; CREATE SCHEMA ${schema};`;
+async function dropAndRecreateSchema(context, schema) {
+    await context.executeSql(`DROP SCHEMA IF EXISTS ${schema} CASCADE; CREATE SCHEMA ${schema};`);
 }
 async function normalizeArgs(tablesOrRoutine, routineOrOptions, optionsOrStatements) {
     if (Array.isArray(tablesOrRoutine)) {

package/dist/utils/value-processor.js

@@ -65,8 +65,9 @@ class ValueProcessor {
             if (property.options.onUpdate && moment === 'update') {
                 instance[key] = property.options.onUpdate();
             }
-            if (key in values) {
-                instance[key] = values[property.options.columnName];
+            const columnName = property.options.columnName;
+            if (columnName in values) {
+                instance[key] = values[columnName];
             }
         });
         if (relations) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "A simple ORM for Cheetah.js",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "d3d5471df38cbb87399a11df1e59945085ab2288"
+  "gitHead": "91b624454730ef136975e456b365aa220378f4d2"
 }