@stonyx/orm 0.1.0 → 0.2.1-alpha.0

package/src/orm-request.js

@@ -0,0 +1,189 @@
+import { Request } from '@stonyx/rest-server';
+import { createRecord, store } from '@stonyx/orm';
+import { pluralize } from '@stonyx/utils/string';
+
+const methodAccessMap = {
+  GET: 'read',
+  POST: 'create',
+  DELETE: 'delete',
+  PATCH: 'update',
+};
+
+function getId({ id }) {
+  if (isNaN(id)) return id;
+
+  return parseInt(id);
+}
+
+function buildResponse(data, includeParam, recordOrRecords) {
+  const response = { data };
+
+  if (!includeParam) return response;
+
+  const includes = parseInclude(includeParam);
+  if (includes.length === 0) return response;
+
+  const includedRecords = collectIncludedRecords(recordOrRecords, includes);
+  if (includedRecords.length > 0) {
+    response.included = includedRecords.map(record => record.toJSON());
+  }
+
+  return response;
+}
+
+/**
+ * Recursively traverse an include path and collect related records
+ * @param {Array<Record>} currentRecords - Records to process at current depth
+ * @param {Array<string>} includePath - Full path array (e.g., ['owner', 'pets', 'traits'])
+ * @param {number} depth - Current depth in the path
+ * @param {Map} seen - Deduplication map
+ * @param {Array} included - Accumulator for included records
+ */
+function traverseIncludePath(currentRecords, includePath, depth, seen, included) {
+  if (depth >= includePath.length) return; // Reached end of path
+
+  const relationshipName = includePath[depth];
+  const nextRecords = [];
+
+  for (const record of currentRecords) {
+    if (!record.__relationships) continue;
+    if (!(relationshipName in record.__relationships)) continue;
+
+    const relatedRecords = record.__relationships[relationshipName];
+    if (!relatedRecords) continue;
+
+    // Handle both belongsTo (single) and hasMany (array)
+    const recordsToProcess = Array.isArray(relatedRecords)
+      ? relatedRecords
+      : [relatedRecords];
+
+    for (const relatedRecord of recordsToProcess) {
+      if (!relatedRecord) continue;
+
+      const type = relatedRecord.__model.__name;
+      const id = relatedRecord.id;
+
+      // Initialize Set for this type if needed
+      if (!seen.has(type)) {
+        seen.set(type, new Set());
+      }
+
+      // Check if we've already seen this type+id combination
+      if (!seen.get(type).has(id)) {
+        seen.get(type).add(id);
+        included.push(relatedRecord);
+        nextRecords.push(relatedRecord); // Prepare for next depth level
+      } else if (depth < includePath.length - 1) {
+        // Even if we've seen this record, we might need it for deeper traversal
+        nextRecords.push(relatedRecord);
+      }
+    }
+  }
+
+  // If there are more segments in the path, recursively process
+  if (depth < includePath.length - 1 && nextRecords.length > 0) {
+    traverseIncludePath(nextRecords, includePath, depth + 1, seen, included);
+  }
+}
+
+function collectIncludedRecords(data, includes) {
+  if (!includes || includes.length === 0) return [];
+  if (!data) return [];
+
+  const seen = new Map(); // Map<type, Set<id>> for deduplication
+  const included = [];
+
+  // Normalize to array for consistent processing
+  const records = Array.isArray(data) ? data : [data];
+
+  // Process each include path
+  for (const includePath of includes) {
+    traverseIncludePath(records, includePath, 0, seen, included);
+  }
+
+  return included;
+}
+
+function parseInclude(includeParam) {
+  if (!includeParam || typeof includeParam !== 'string') return [];
+
+  return includeParam
+    .split(',')
+    .map(rel => rel.trim())
+    .filter(rel => rel.length > 0)
+    .map(rel => rel.split('.')); // Parse nested paths: "owner.pets" → ["owner", "pets"]
+}
+
+export default class OrmRequest extends Request {
+  constructor({ model, access }) {
+    super(...arguments);
+
+    this.access = access;
+    const pluralizedModel = pluralize(model);
+
+    this.handlers = {
+      get: {
+        [`/${pluralizedModel}`]: (request, { filter }) => {
+          const allRecords = Array.from(store.get(model).values());
+          const recordsToReturn = filter ? allRecords.filter(filter) : allRecords;
+          const data = recordsToReturn.map(record => record.toJSON());
+
+          return buildResponse(data, request.query?.include, recordsToReturn);
+        },
+
+        [`/${pluralizedModel}/:id`]: (request) => {
+          const record = store.get(model, getId(request.params));
+
+          if (!record) return 404; // Record not found
+
+          return buildResponse(record.toJSON(), request.query?.include, record);
+        }
+      },
+
+      patch: {
+        [`/${pluralizedModel}/:id`]: async ({ body, params }) => {
+          const record = store.get(model, getId(params));
+          const { attributes } = body?.data || {};
+
+          if (!attributes) return 400; // Bad request
+
+          // Apply updates 1 by 1 to utilize built-in transform logic, ignore id key
+          for (const [key, value] of Object.entries(attributes)) {
+            if (!record.hasOwnProperty(key)) continue;
+            if (key === 'id') continue;
+
+            record[key] = value
+          };
+
+          return { data: record.toJSON() };
+        }
+      },
+
+      post: {
+        [`/${pluralizedModel}`]: ({ body }) => {
+          const { attributes } = body?.data || {};
+
+          if (!attributes) return 400; // Bad request
+
+          const record = createRecord(model, attributes, { serialize: false });
+
+          return { data: record.toJSON() };
+        }
+      },
+
+      delete: {
+        [`/${pluralizedModel}/:id`]: ({ params }) => {
+          store.remove(model, getId(params));
+        }
+      }
+    }
+  }
+
+  auth(request, state) {
+    const access = this.access(request);
+
+    if (!access) return 403;
+    if (Array.isArray(access) && !access.includes(methodAccessMap[request.method])) return 403;
+    if (typeof access === 'function') state.filter = access;
+  }
+}

package/src/record.js

@@ -1,7 +1,8 @@
-import DB from "@stonyx/orm/db";
-
+import { store } from './index.js';
+import { getComputedProperties } from "./serializer.js";
 export default class Record {
   __data = {};
+  __relationships = {};
   __serialized = false;
 
   constructor(model, serializer) {
@@ -9,20 +10,83 @@ export default class Record {
     this.__serializer = serializer;
   }
 
-  serialize(rawData) {
+  serialize(rawData, options={}) {
     const { __data:data } = this;
     
-    if (this.__serialized)  return data;
+    if (this.__serialized && !options.update) {
+      const relatedIds = {};
+
+      for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
+        relatedIds[key] = Array.isArray(childRecord) 
+        ? childRecord.map(r => r.id)
+        : childRecord?.id ?? null;
+      }
+
+      return { ...data, ...relatedIds };
+    }
 
     const normalizedData = this.__serializer.normalize(rawData);
-    this.__serializer.setProperties(normalizedData, this);
+    this.__serializer.setProperties(normalizedData, this, options);
 
     return data;
   }
 
-  save() {
-    const { __name:key } = this.__model;
+  // Similar to serialize, but preserves top level relationship records
+  format() {
+    if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
+    
+    const { __data:data } = this;
+    const records = {};
+
+    for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
+      records[key] = Array.isArray(childRecord) 
+      ? childRecord.map(r => r.serialize())
+      : childRecord?.serialize() ?? null;
+    }
+
+    return { ...data, ...records };
+  }
+
+  // Formats record for JSON API output
+  toJSON() {
+    if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
     
-    new DB().data[key] = this.serialize();
+    const { __data:data } = this;
+    const relationships = {};
+    const attributes = { ...data };
+    delete attributes.id;
+
+    for (const [key, getter] of getComputedProperties(this.__model)) {
+      attributes[key] = getter.call(this);
+    }
+
+    for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
+      relationships[key] = {
+        data: Array.isArray(childRecord) 
+        ? childRecord.map(r => ({ type: r.__model.__name, id: r.id }))
+        : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null
+      };
+    }
+
+    return {
+      attributes,
+      relationships,
+      id: data.id,
+      type: this.__model.__name,
+    };
+  }
+
+  unload(options={}) {
+    store.unloadRecord(this.__model.__name, this.id, options);
+  }
+
+  clean() {
+    try {
+      for (const key of Object.keys(this)) {
+        delete this[key];
+      }
+    } catch {
+      // Ignore errors during cleanup, as some keys may not be deletable
+    }
   }
 }

package/src/relationships.js

@@ -0,0 +1,43 @@
+import { relationships } from "@stonyx/orm";
+
+export default class Relationships {
+  constructor() {
+    if (Relationships.instance) return Relationships.instance;
+    Relationships.instance = this;
+
+    this.data = new Map();
+  }
+
+  get(key) {
+    return this.data.get(key);
+  }
+
+  set(key, value) {
+    this.data.set(key, value);
+  }
+}
+
+// TODO: Refactor mapping to remove a level of iteration
+export function getRelationships(type, sourceModel, targetModel, relationshipId) {
+  const allRelationships = relationships.get(type);
+  
+  // create relationship map for this type of it doesn't already exist
+  if (!allRelationships.has(sourceModel)) allRelationships.set(sourceModel, new Map());
+  
+  const modelRelationship = allRelationships.get(sourceModel);
+
+  if (!modelRelationship.has(targetModel)) modelRelationship.set(targetModel, new Map());
+
+  const relationship = modelRelationship.get(targetModel);
+
+  // TODO: Determine whether already having id should be handled differently
+  //if (relationship.has(relationshipId)) return;
+
+  return relationship;
+}
+
+export function getHasManyRelationships(sourceModel, targetModel) {
+  return relationships.get('hasMany').get(sourceModel)?.get(targetModel);
+}
+
+export const TYPES = ['global', 'hasMany', 'belongsTo', 'pending'];

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;
+}