@stonyx/orm 0.0.7 → 0.2.0

package/src/serializer.js

@@ -1,6 +1,5 @@
 import config from 'stonyx/config';
-import { makeArray } from '@stonyx/utils/object';
-import { get, getComputedProperties } from '@stonyx/orm/utils';
+import { get, makeArray } from '@stonyx/utils/object';
 
 const RESERVED_KEYS = ['__name'];
 
@@ -48,7 +47,7 @@ function query(rawData, pathPrefix, subPath) {
   }
 }
 
-export default class BaseSerializer {
+export default class Serializer {
   map = {};
   path = '';
 
@@ -61,25 +60,28 @@ export default class BaseSerializer {
    * the ModelProperty object, while setting parsed values to the record's
    * __data property, which represents the serialized version of the data
    */
-  setProperties(rawData, record) {
+  setProperties(rawData, record, options) {
     const { path, model } = this;
     const keys = Object.keys(model).filter(key => !RESERVED_KEYS.includes(key));
     const pathPrefix = path ? `${path}.` : '';
-    const { __data:parsedData } = record;
-    const { postTransform } = model;
+    const { __data:parsedData, __relationships:relatedRecords } = record;
 
     for (const key of keys) {
-      const subPath = this.map[key] || key;
+      const subPath = options.serialize ? (this.map[key] || key) : key;
       const handler = model[key];
       const data = query(rawData, pathPrefix, subPath);
 
+      // Ignore null values on updates (TODO: What if we want it set to null?)
+      if (data === null && options.update) continue;
+
       // Relationship handling
       if (typeof handler === 'function') {
-        const childRecord = handler(data);
+        // Pass relationship key name to handler for pending fulfillment
+        const handlerOptions = { ...options, _relationshipKey: key };
+        const childRecord = handler(record, data, handlerOptions);
+
         record[key] = childRecord
-        parsedData[key] = Array.isArray(childRecord) 
-          ? childRecord.map(record => record.serialize())
-          : childRecord.serialize();
+        relatedRecords[key] = childRecord;
 
         continue;
       }
@@ -91,22 +93,28 @@ export default class BaseSerializer {
         continue;
       }
 
-      // We access modelProperty.value twice due to getter/setter in ModelProperty class
-      handler.value = data;
-      let transformedValue = handler.value;
-
-      if (postTransform) transformedValue = postTransform(transformedValue);
-
-      parsedData[key] = transformedValue;
-      record[key] = handler;
+      Object.defineProperty(record, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => handler.value,
+        set(newValue) {
+          handler.ignoreFirstTransform = !options.transform;
+          handler.value = newValue;
+          parsedData[key] = handler.value;
+        }
+      });
+
+      record[key] = data;
     }
 
+    if (options.update) return;
+
     // Serialize computed properties
-    for (const [key, method] of getComputedProperties(this.model)) {
-      const value = method.bind(parsedData)();
-      
-      parsedData[key] = value;
-      record[key] = value;
+    for (const [key, getter] of getComputedProperties(this.model)) {
+      Object.defineProperty(record, key, {
+        enumerable: true,
+        get: () => getter.call(record)
+      });
     }
 
     record.__serialized = true;
@@ -119,3 +127,12 @@ export default class BaseSerializer {
     return data;
   }
 }
+
+export function getComputedProperties(classInstance) {
+  const proto = Object.getPrototypeOf(classInstance);
+  if (!proto || proto === Object.prototype) return [];
+  
+  return Object.entries(Object.getOwnPropertyDescriptors(proto))
+    .filter(([key, descriptor]) => key !== 'constructor' && descriptor.get)
+    .map(([key, descriptor]) => [key, descriptor.get]);
+}

package/src/setup-rest-server.js

@@ -0,0 +1,57 @@
+import { waitForModule } from 'stonyx';
+import { store } from '@stonyx/orm';
+import OrmRequest from './orm-request.js';
+import MetaRequest from './meta-request.js';
+import RestServer from '@stonyx/rest-server';
+import { forEachFileImport } from '@stonyx/utils/file';
+import { dbKey } from './db.js';
+import log from 'stonyx/log';
+
+export default async function(route, accessPath, metaRoute) {
+  let accessFiles = {};
+  
+  try {
+    await forEachFileImport(accessPath, accessClass => {
+      const accessInstance = new accessClass();
+      const { models } = accessInstance;
+
+      if (!models) throw new Error(`Access class "${accessClass.name}" must define a "models" list`);
+
+      if (models.length === 0) return; // No models to assign access to
+      if (typeof accessInstance.access !== 'function') throw new Error(`Access class "${accessClass.name}" must declare an "access" method`);
+
+      const availableModels = Array.from(store.data.keys());
+
+      for (const model of models === '*' ? availableModels : models) {
+        if (model === dbKey) continue;
+        if (!store.data.has(model)) throw new Error(`Unable to define access for Invalid Model "${model}". Model does not exist`);
+        if (accessFiles[model]) throw new Error(`Access for model "${model}" has already been defined by another access class.`);
+
+        accessFiles[model] = accessInstance.access;
+      }
+    });
+  } catch (error) {
+    log.error(error.message);
+    log.warn('You must define a valid access configuration file in order to access ORM generated REST endpoints.');
+  }
+
+  await waitForModule('rest-server');
+
+  // Remove "/" prefix and name mount point accordingly
+  const name = route === '/' ? 'index' : (route[0] === '/' ? route.slice(1) : route);
+
+  // Configure endpoints for models with access configuration
+  for (const [model, access] of Object.entries(accessFiles)) {
+    RestServer.instance.mountRoute(OrmRequest, { name, options: { model, access } }); 
+  }
+
+  // Mount the meta route when metaRoute config is enabled
+  if (metaRoute) {
+    log.warn('SECURITY RISK! - Meta route is enabled via metaRoute config. This feature is intended for development purposes only!');
+
+    RestServer.instance.mountRoute(MetaRequest, { name });
+  }
+
+  // Cleanup references
+  accessFiles = null;
+}

package/src/store.js

@@ -0,0 +1,211 @@
+import { relationships } from '@stonyx/orm';
+import { TYPES } from './relationships.js';
+
+export default class Store {
+  constructor() {
+    if (Store.instance) return Store.instance;
+    Store.instance = this;
+
+    this.data = new Map();
+  }
+
+  get(key, id) {
+    if (!id) return this.data.get(key);
+
+    return this.data.get(key)?.get(id);
+  }
+
+  set(key, value) {
+    this.data.set(key, value);
+  }
+
+  remove(key, id) {
+    if (id) return this.unloadRecord(key, id);
+
+    this.unloadAllRecords(key);
+  }
+
+  unloadRecord(model, id, options={}) {
+    const modelStore = this.data.get(model);
+
+    if (!modelStore) {
+      console.warn(`[Store] Cannot unload record: model "${model}" not found in store`);
+      return;
+    }
+
+    const record = modelStore.get(id);
+
+    if (!record) {
+      console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store`);
+      return;
+    }
+
+    const { toUnload, visited } = options.includeChildren
+      ? this._buildUnloadQueue(record, options)
+      : { toUnload: [{ record, modelName: model, recordId: id }], visited: new Set([`${model}:${id}`]) };
+
+    for (const item of toUnload.reverse()) {
+      const { record: recordToUnload, modelName, recordId } = item;
+
+      this._removeFromHasManyArrays(modelName, recordId, visited);
+      this._nullifyBelongsToReferences(modelName, recordId, visited);
+      this._cleanupRelationshipRegistries(modelName, recordId);
+      recordToUnload.clean();
+
+      this.data.get(modelName).delete(recordId);
+    }
+  }
+
+  unloadAllRecords(model, options={}) {
+    const modelStore = this.data.get(model);
+
+    if (!modelStore) {
+      console.warn(`[Store] Cannot unload all records: model "${model}" not found in store`);
+      return;
+    }
+
+    const recordIds = Array.from(modelStore.keys());
+
+    for (const id of recordIds) {
+      if (modelStore.has(id)) {
+        this.unloadRecord(model, id, options);
+      }
+    }
+
+    for (const relationshipType of TYPES) relationships.get(relationshipType).delete(model);
+  }
+
+  _removeFromHasManyArrays(modelName, recordId, visited) {
+    const hasManyRegistry = relationships.get('hasMany');
+
+    for (const [sourceModel, targetModels] of hasManyRegistry) {
+      const targetModelMap = targetModels.get(modelName);
+      if (!targetModelMap) continue;
+
+      for (const [sourceRecordId, hasManyArray] of targetModelMap) {
+        const sourceKey = `${sourceModel}:${sourceRecordId}`;
+
+        // Don't modify arrays of records being deleted
+        if (visited.has(sourceKey)) continue;
+
+        const index = hasManyArray.findIndex(r => r && r.id === recordId);
+        if (index !== -1) hasManyArray.splice(index, 1);
+      }
+    }
+  }
+
+  _nullifyBelongsToReferences(modelName, recordId, visited) {
+    const belongsToRegistry = relationships.get('belongsTo');
+
+    for (const [sourceModel, targetModels] of belongsToRegistry) {
+      const targetModelMap = targetModels.get(modelName);
+      if (!targetModelMap) continue;
+
+      for (const [sourceRecordId, belongsToRecord] of targetModelMap) {
+        if (belongsToRecord && belongsToRecord.id === recordId) {
+          const sourceKey = `${sourceModel}:${sourceRecordId}`;
+
+          if (visited.has(sourceKey)) continue;
+          targetModelMap.set(sourceRecordId, null);
+
+          const sourceRecord = this.get(sourceModel, sourceRecordId);
+          if (sourceRecord && sourceRecord.__relationships) {
+            for (const [key, value] of Object.entries(sourceRecord.__relationships)) {
+              if (value && value.id === recordId) {
+                sourceRecord.__relationships[key] = null;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  _cleanupRelationshipRegistries(modelName, recordId) {
+    const hasManyMap = relationships.get('hasMany').get(modelName);
+    if (hasManyMap) {
+      for (const [, recordMap] of hasManyMap) recordMap.delete(recordId);
+    }
+
+    const belongsToMap = relationships.get('belongsTo').get(modelName);
+    if (belongsToMap) {
+      for (const [, recordMap] of belongsToMap) recordMap.delete(recordId);
+    }
+
+    const pendingMap = relationships.get('pending').get(modelName);
+    if (pendingMap) pendingMap.delete(recordId);
+  }
+
+  /**
+   * Extracts hasMany and non-bidirectional belongsTo children from a record
+   * @private
+   */
+  _getChildren(record) {
+    const children = [];
+
+    if (!record.__relationships) return children;
+
+    for (const [key, value] of Object.entries(record.__relationships)) {
+      // hasMany children - always include
+      if (Array.isArray(value)) {
+        for (const childRecord of value) {
+          if (childRecord) children.push({ childRecord, relationshipKey: key, type: 'hasMany' });
+        }
+      } else if (value && !this._isBidirectionalRelationship(
+        record.__model.__name,
+        value.__model.__name
+      )) {
+        children.push({ childRecord: value, relationshipKey: key, type: 'belongsTo' });
+      }
+    }
+
+    return children;
+  }
+
+  _isBidirectionalRelationship(sourceModel, targetModel) {
+    const hasManyRegistry = relationships.get('hasMany');
+    const inverseMap = hasManyRegistry.get(targetModel)?.get(sourceModel);
+
+    return inverseMap && inverseMap.size > 0;
+  }
+
+  _buildUnloadQueue(record, options) {
+    const visited = new Set();
+    const toUnload = [];
+    const queue = [{
+      record,
+      modelName: record.__model.__name,
+      recordId: record.id,
+      isRoot: true,
+      depth: 0
+    }];
+
+    while (queue.length > 0) {
+      const item = queue.shift();
+      const key = `${item.modelName}:${item.recordId}`;
+
+      if (visited.has(key)) continue;
+      visited.add(key);
+
+      toUnload.push(item);
+
+      // Add children to queue if includeChildren is enabled
+      if (options.includeChildren) {
+        const children = this._getChildren(item.record);
+        for (const { childRecord } of children) {
+          if (childRecord) {
+            queue.push({
+              record: childRecord,
+              modelName: childRecord.__model.__name,
+              recordId: childRecord.id,
+              isRoot: false,
+              depth: item.depth + 1
+            });
+          }
+        }
+      }
+    }
+
+    return { toUnload, visited };
+  }
+}

package/src/transforms.js

@@ -1,3 +1,5 @@
+import { getTimestamp } from "@stonyx/utils/date";
+
 const transforms = {
   boolean: value => typeof value === 'string' ? value.trim().toLowerCase() === 'true' : !!value,
   date: value => value ? new Date(value) : null,
@@ -5,13 +7,14 @@ const transforms = {
   number: value => parseInt(value),
   passthrough: value => value,
   string: value => String(value),
+  timestamp: value => getTimestamp(value),
   trim: value => value?.trim(),
   uppercase: value => value?.toUpperCase(),
 };
 
 // Math Proxies
 ['ceil', 'floor', 'round'].forEach(method => {
-  transforms[method] = value => Math[method](value)();
+  transforms[method] = value => Math[method](value);
 });
 
 export default transforms;

package/stonyx-bootstrap.cjs

@@ -0,0 +1,30 @@
+/**
+ * commonJS Bootstrap loading - Stonyx must be loaded first, prior to the rest of the application
+ */
+const { default:Stonyx } = require('stonyx');
+const { default:config } = require('./config/environment.js');
+
+// Override paths for tests
+Object.assign(config.paths, { 
+  access: './test/sample/access',
+  model: './test/sample/models',
+  serializer: './test/sample/serializers',
+  transform: './test/sample/transforms'
+})
+
+// Override db settings for tests
+Object.assign(config.db, {
+  file: './test/sample/db.json',
+  schema: './test/sample/db-schema.js'
+});
+
+// Create restServer module path for tests
+config.modules = {
+  restServer: {
+    dir: './test/sample/requests'
+  }
+}
+
+new Stonyx(config, __dirname);
+
+module.exports = Stonyx;

package/.nvmrc

@@ -1 +0,0 @@
-v22.18.0

package/src/utils.js

@@ -1,19 +0,0 @@
-export function get(obj, path) {
-  if (arguments.length !== 2) return console.error('Get must be called with two arguments; an object and a property key.');
-  if (!obj) return console.error(`Cannot call get with '${path}' on an undefined object.`);
-  if (typeof path !== 'string') return console.error('The path provided to get must be a string.');
-
-  for (const key of path.split('.')) {
-    if (obj[key] === undefined) return null;
-
-    obj = obj[key];
-  }
-
-  return obj;
-}
-
-export function getComputedProperties(classInstance) {
-  return Object.entries(Object.getOwnPropertyDescriptors(Object.getPrototypeOf(classInstance))).filter(
-    ([ key, descriptor ]) => key !== 'constructor' && descriptor.get
-  ).map(([ key, descriptor ]) => [ key, descriptor.get ]);
-}