@stonyx/orm 0.2.1-alpha.0 → 0.2.1-alpha.10

package/src/orm-request.js

@@ -1,6 +1,9 @@
 import { Request } from '@stonyx/rest-server';
-import { createRecord, store } from '@stonyx/orm';
-import { pluralize } from '@stonyx/utils/string';
+import Orm, { createRecord, updateRecord, store } from '@stonyx/orm';
+import { camelCaseToKebabCase } from '@stonyx/utils/string';
+import { getPluralName } from './plural-registry.js';
+import { getBeforeHooks, getAfterHooks } from './hooks.js';
+import config from 'stonyx/config';
 
 const methodAccessMap = {
   GET: 'read',
@@ -9,15 +12,62 @@ const methodAccessMap = {
   PATCH: 'update',
 };
 
+const WRITE_OPERATIONS = new Set(['create', 'update', 'delete']);
+
+// Helper to detect relationship type from function
+function getRelationshipInfo(property) {
+  if (typeof property !== 'function') return null;
+  const fnStr = property.toString();
+  if (fnStr.includes(`getRelationships('belongsTo',`)) {
+    return { type: 'belongsTo', isArray: false };
+  }
+  if (fnStr.includes(`getRelationships('hasMany',`)) {
+    return { type: 'hasMany', isArray: true };
+  }
+  return null;
+}
+
+// Helper to introspect model relationships
+function getModelRelationships(modelName) {
+  const { modelClass } = Orm.instance.getRecordClasses(modelName);
+  if (!modelClass) return {};
+
+  const model = new modelClass(modelName);
+  const relationships = {};
+
+  for (const [key, property] of Object.entries(model)) {
+    if (key.startsWith('__')) continue;
+    const info = getRelationshipInfo(property);
+    if (info) {
+      relationships[key] = info;
+    }
+  }
+
+  return relationships;
+}
+
+// Helper to build base URL from request
+function getBaseUrl(request) {
+  const protocol = request.protocol || 'http';
+  const host = request.get('host');
+  return `${protocol}://${host}`;
+}
+
 function getId({ id }) {
   if (isNaN(id)) return id;
 
   return parseInt(id);
 }
 
-function buildResponse(data, includeParam, recordOrRecords) {
+function buildResponse(data, includeParam, recordOrRecords, options = {}) {
+  const { links, baseUrl } = options;
   const response = { data };
 
+  // Add top-level links
+  if (links) {
+    response.links = links;
+  }
+
   if (!includeParam) return response;
 
   const includes = parseInclude(includeParam);
@@ -25,7 +75,7 @@ function buildResponse(data, includeParam, recordOrRecords) {
 
   const includedRecords = collectIncludedRecords(recordOrRecords, includes);
   if (includedRecords.length > 0) {
-    response.included = includedRecords.map(record => record.toJSON());
+    response.included = includedRecords.map(record => record.toJSON({ baseUrl }));
   }
 
   return response;
@@ -114,69 +164,333 @@ function parseInclude(includeParam) {
     .map(rel => rel.split('.')); // Parse nested paths: "owner.pets" → ["owner", "pets"]
 }
 
+function parseFields(query) {
+  const fields = new Map();
+  if (!query) return fields;
+
+  for (const [key, value] of Object.entries(query)) {
+    const match = key.match(/^fields\[(\w+)\]$/);
+    if (match && typeof value === 'string') {
+      const modelName = match[1];
+      const fieldNames = value.split(',').map(f => f.trim()).filter(f => f);
+      fields.set(modelName, new Set(fieldNames));
+    }
+  }
+
+  return fields;
+}
+
+function parseFilters(query) {
+  const filters = [];
+  if (!query) return filters;
+
+  for (const [key, value] of Object.entries(query)) {
+    const match = key.match(/^filter\[(.+)\]$/);
+    if (match && typeof value === 'string') {
+      filters.push({ path: match[1].split('.'), value });
+    }
+  }
+
+  return filters;
+}
+
+function createFilterPredicate(filters) {
+  if (filters.length === 0) return null;
+
+  return (record) => filters.every(({ path, value }) => {
+    let current = record;
+
+    for (const segment of path) {
+      if (current == null) return false;
+      current = current[segment];
+    }
+
+    return String(current) === value;
+  });
+}
+
 export default class OrmRequest extends Request {
   constructor({ model, access }) {
     super(...arguments);
 
+    this.model = model;
     this.access = access;
-    const pluralizedModel = pluralize(model);
+    const pluralizedModel = getPluralName(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());
+    const modelRelationships = getModelRelationships(model);
 
-          return buildResponse(data, request.query?.include, recordsToReturn);
-        },
+    // Define raw handlers first
+    const getCollectionHandler = async (request, { filter: accessFilter }) => {
+      const allRecords = await store.findAll(model);
 
-        [`/${pluralizedModel}/:id`]: (request) => {
-          const record = store.get(model, getId(request.params));
+      const queryFilters = parseFilters(request.query);
+      const queryFilterPredicate = createFilterPredicate(queryFilters);
+      const fieldsMap = parseFields(request.query);
+      const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
 
-          if (!record) return 404; // Record not found
+      let recordsToReturn = allRecords;
+      if (accessFilter) recordsToReturn = recordsToReturn.filter(accessFilter);
+      if (queryFilterPredicate) recordsToReturn = recordsToReturn.filter(queryFilterPredicate);
 
-          return buildResponse(record.toJSON(), request.query?.include, record);
-        }
-      },
+      const baseUrl = getBaseUrl(request);
+      const data = recordsToReturn.map(record => record.toJSON({ fields: modelFields, baseUrl }));
 
-      patch: {
-        [`/${pluralizedModel}/:id`]: async ({ body, params }) => {
-          const record = store.get(model, getId(params));
-          const { attributes } = body?.data || {};
+      return buildResponse(data, request.query?.include, recordsToReturn, {
+        links: { self: `${baseUrl}/${pluralizedModel}` },
+        baseUrl
+      });
+    };
+
+    const getSingleHandler = async (request) => {
+      const record = await store.find(model, getId(request.params));
+      if (!record) return 404;
+
+      const fieldsMap = parseFields(request.query);
+      const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
+
+      const baseUrl = getBaseUrl(request);
+      return buildResponse(record.toJSON({ fields: modelFields, baseUrl }), request.query?.include, record, {
+        links: { self: `${baseUrl}/${pluralizedModel}/${request.params.id}` },
+        baseUrl
+      });
+    };
 
-          if (!attributes) return 400; // Bad request
+    const createHandler = async ({ body, query }) => {
+      const { type, id, attributes, relationships: rels } = body?.data || {};
 
-          // 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;
+      if (!type) return 400; // Bad request
 
-            record[key] = value
-          };
+      const fieldsMap = parseFields(query);
+      const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
 
-          return { data: record.toJSON() };
+      // Check for duplicate ID
+      if (id !== undefined && await store.find(model, id)) return 409; // Conflict
+
+      const { id: _ignoredId, ...sanitizedAttributes } = attributes || {};
+
+      // Extract relationship IDs from JSON:API relationships object
+      if (rels) {
+        for (const [key, value] of Object.entries(rels)) {
+          const relData = value?.data;
+          if (relData && relData.id !== undefined) {
+            sanitizedAttributes[key] = relData.id;
+          }
         }
-      },
+      }
 
-      post: {
-        [`/${pluralizedModel}`]: ({ body }) => {
-          const { attributes } = body?.data || {};
+      const recordAttributes = id !== undefined ? { id, ...sanitizedAttributes } : sanitizedAttributes;
+      const record = createRecord(model, recordAttributes, { serialize: false });
+
+      return { data: record.toJSON({ fields: modelFields }) };
+    };
 
-          if (!attributes) return 400; // Bad request
+    const updateHandler = async ({ body, params }) => {
+      const record = await store.find(model, getId(params));
+      const { attributes, relationships: rels } = body?.data || {};
 
-          const record = createRecord(model, attributes, { serialize: false });
+      if (!attributes && !rels) return 400; // Bad request
 
-          return { data: record.toJSON() };
+      // Apply attribute updates 1 by 1 to utilize built-in transform logic, ignore id key
+      if (attributes) {
+        for (const [key, value] of Object.entries(attributes)) {
+          if (!record.hasOwnProperty(key)) continue;
+          if (key === 'id') continue;
+
+          record[key] = value
+        };
+      }
+
+      // Apply relationship updates via updateRecord to properly resolve references
+      if (rels) {
+        const relUpdates = {};
+        for (const [key, value] of Object.entries(rels)) {
+          const relData = value?.data;
+          if (relData && relData.id !== undefined) {
+            relUpdates[key] = relData.id;
+          }
         }
-      },
+        if (Object.keys(relUpdates).length > 0) {
+          updateRecord(record, relUpdates);
+        }
+      }
 
+      return { data: record.toJSON() };
+    };
+
+    const deleteHandler = ({ params }) => {
+      store.remove(model, getId(params));
+      return 204;
+    };
+
+    // Wrap handlers with hooks
+    this.handlers = {
+      get: {
+        '/': this._withHooks('list', getCollectionHandler),
+        '/:id': this._withHooks('get', getSingleHandler),
+        ...this._generateRelationshipRoutes(model, pluralizedModel, modelRelationships)
+      },
+      patch: {
+        '/:id': this._withHooks('update', updateHandler)
+      },
+      post: {
+        '/': this._withHooks('create', createHandler)
+      },
       delete: {
-        [`/${pluralizedModel}/:id`]: ({ params }) => {
-          store.remove(model, getId(params));
+        '/:id': this._withHooks('delete', deleteHandler)
+      }
+    }
+  }
+
+  // Wraps a handler with before/after hook execution
+  _withHooks(operation, handler) {
+    return async (request, state) => {
+      // Build context object for hooks
+      const context = {
+        model: this.model,
+        operation,
+        request,
+        params: request.params,
+        body: request.body,
+        query: request.query,
+        state,
+      };
+
+      // Capture old state for operations that modify data
+      if (operation === 'update' || operation === 'delete') {
+        const existingRecord = await store.find(this.model, getId(request.params));
+        if (existingRecord) {
+          // Deep copy the record's data to preserve old state
+          context.oldState = JSON.parse(JSON.stringify(existingRecord.__data || existingRecord));
+        }
+        if (operation === 'delete') {
+          context.recordId = getId(request.params);
+        }
+      }
+
+      // Run before hooks sequentially (can halt by returning a value)
+      for (const hook of getBeforeHooks(operation, this.model)) {
+        const result = await hook(context);
+        if (result !== undefined) {
+          // Hook returned a value - halt operation and return result
+          return result;
         }
       }
+
+      // Execute main handler
+      const response = await handler(request, state);
+
+      // Persist to MySQL for write operations
+      if (Orm.instance.mysqlDb && WRITE_OPERATIONS.has(operation)) {
+        await Orm.instance.mysqlDb.persist(operation, this.model, context, response);
+      }
+
+      // Add response and relevant records to context
+      context.response = response;
+
+      if (operation === 'get' && response?.data && !Array.isArray(response.data)) {
+        context.record = await store.find(this.model, getId(request.params));
+      } else if (operation === 'list' && response?.data) {
+        context.records = await store.findAll(this.model);
+      } else if (operation === 'create' && response?.data?.id) {
+        // For create, get the record from store using the ID from the response
+        const recordId = isNaN(response.data.id) ? response.data.id : parseInt(response.data.id);
+        context.record = store.get(this.model, recordId);
+      } else if (operation === 'update' && response?.data) {
+        context.record = store.get(this.model, getId(request.params));
+      } else if (operation === 'delete') {
+        // For delete, the record may no longer exist, but we have oldState
+        context.recordId = getId(request.params);
+      }
+
+      // Run after hooks sequentially
+      for (const hook of getAfterHooks(operation, this.model)) {
+        await hook(context);
+      }
+
+      // Auto-save DB after write operations when configured
+      if (config.orm.db.autosave === 'onUpdate' && WRITE_OPERATIONS.has(operation)) {
+        await Orm.db.save();
+      }
+
+      return response;
+    };
+  }
+
+  _generateRelationshipRoutes(model, pluralizedModel, modelRelationships) {
+    const routes = {};
+
+    for (const [relationshipName, info] of Object.entries(modelRelationships)) {
+      // Dasherize the relationship name for URL paths (e.g., accessLinks -> access-links)
+      const dasherizedName = camelCaseToKebabCase(relationshipName);
+
+      // Related resource route: GET /:id/{relationship}
+      routes[`/:id/${dasherizedName}`] = async (request) => {
+        const record = await store.find(model, getId(request.params));
+        if (!record) return 404;
+
+        const relatedData = record.__relationships[relationshipName];
+        const baseUrl = getBaseUrl(request);
+
+        let data;
+        if (info.isArray) {
+          // hasMany - return array
+          data = (relatedData || []).map(r => r.toJSON({ baseUrl }));
+        } else {
+          // belongsTo - return single or null
+          data = relatedData ? relatedData.toJSON({ baseUrl }) : null;
+        }
+
+        return {
+          links: { self: `${baseUrl}/${pluralizedModel}/${request.params.id}/${dasherizedName}` },
+          data
+        };
+      };
+
+      // Relationship linkage route: GET /:id/relationships/{relationship}
+      routes[`/:id/relationships/${dasherizedName}`] = async (request) => {
+        const record = await store.find(model, getId(request.params));
+        if (!record) return 404;
+
+        const relatedData = record.__relationships[relationshipName];
+        const baseUrl = getBaseUrl(request);
+
+        let data;
+        if (info.isArray) {
+          // hasMany - return array of linkage objects
+          data = (relatedData || []).map(r => ({ type: r.__model.__name, id: r.id }));
+        } else {
+          // belongsTo - return single linkage or null
+          data = relatedData ? { type: relatedData.__model.__name, id: relatedData.id } : null;
+        }
+
+        return {
+          links: {
+            self: `${baseUrl}/${pluralizedModel}/${request.params.id}/relationships/${dasherizedName}`,
+            related: `${baseUrl}/${pluralizedModel}/${request.params.id}/${dasherizedName}`
+          },
+          data
+        };
+      };
     }
+
+    // Catch-all for invalid relationship names on related resource route
+    routes[`/:id/:relationship`] = async (request) => {
+      const record = await store.find(model, getId(request.params));
+      if (!record) return 404;
+
+      // If we reach here, relationship doesn't exist (valid ones were registered above)
+      return 404;
+    };
+
+    // Catch-all for invalid relationship names on relationship linkage route
+    routes[`/:id/relationships/:relationship`] = async (request) => {
+      const record = await store.find(model, getId(request.params));
+      if (!record) return 404;
+
+      return 404;
+    };
+
+    return routes;
   }
 
   auth(request, state) {

package/src/plural-registry.js

@@ -0,0 +1,12 @@
+import { pluralize } from './utils.js';
+
+const registry = new Map();
+
+export function registerPluralName(modelName, modelClass) {
+  const plural = modelClass.pluralName || pluralize(modelName);
+  registry.set(modelName, plural);
+}
+
+export function getPluralName(modelName) {
+  return registry.get(modelName) || pluralize(modelName);
+}

package/src/record.js

@@ -1,5 +1,7 @@
 import { store } from './index.js';
 import { getComputedProperties } from "./serializer.js";
+import { camelCaseToKebabCase } from '@stonyx/utils/string';
+import { getPluralName } from './plural-registry.js';
 export default class Record {
   __data = {};
   __relationships = {};
@@ -8,6 +10,7 @@ export default class Record {
   constructor(model, serializer) {
     this.__model = model;
     this.__serializer = serializer;
+
   }
 
   serialize(rawData, options={}) {
@@ -48,32 +51,64 @@ export default class Record {
   }
 
   // Formats record for JSON API output
-  toJSON() {
+  toJSON(options = {}) {
     if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
-    
+
+    const { fields, baseUrl } = options;
     const { __data:data } = this;
+    const modelName = this.__model.__name;
+    const pluralizedModelName = getPluralName(modelName);
+    const recordId = data.id;
     const relationships = {};
-    const attributes = { ...data };
-    delete attributes.id;
+    const attributes = {};
+
+    for (const [key, value] of Object.entries(data)) {
+      if (key === 'id') continue;
+      if (fields && !fields.has(key)) continue;
+      attributes[key] = value;
+    }
 
     for (const [key, getter] of getComputedProperties(this.__model)) {
+      if (fields && !fields.has(key)) continue;
       attributes[key] = getter.call(this);
     }
 
-    for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-      relationships[key] = {
-        data: Array.isArray(childRecord) 
+    for (const [key, childRecord] of Object.entries(this.__relationships)) {
+      if (fields && !fields.has(key)) continue;
+
+      const relationshipData = Array.isArray(childRecord)
         ? childRecord.map(r => ({ type: r.__model.__name, id: r.id }))
-        : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null
-      };
+        : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null;
+
+      // Dasherize the key for URL paths (e.g., accessLinks -> access-links)
+      const dasherizedKey = camelCaseToKebabCase(key);
+
+      relationships[dasherizedKey] = { data: relationshipData };
+
+      // Add links to relationship if baseUrl provided
+      if (baseUrl) {
+        relationships[dasherizedKey].links = {
+          self: `${baseUrl}/${pluralizedModelName}/${recordId}/relationships/${dasherizedKey}`,
+          related: `${baseUrl}/${pluralizedModelName}/${recordId}/${dasherizedKey}`
+        };
+      }
     }
 
-    return {
+    const result = {
       attributes,
       relationships,
-      id: data.id,
-      type: this.__model.__name,
+      id: recordId,
+      type: modelName,
     };
+
+    // Add resource links if baseUrl provided
+    if (baseUrl) {
+      result.links = {
+        self: `${baseUrl}/${pluralizedModelName}/${recordId}`
+      };
+    }
+
+    return result;
   }
 
   unload(options={}) {

package/src/serializer.js

@@ -71,8 +71,8 @@ export default class Serializer {
       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;
+      // Ignore null/undefined values on updates (TODO: What if we want it set to null?)
+      if ((data === null || data === undefined) && options.update) continue;
 
       // Relationship handling
       if (typeof handler === 'function') {

package/src/setup-rest-server.js

@@ -5,6 +5,7 @@ import MetaRequest from './meta-request.js';
 import RestServer from '@stonyx/rest-server';
 import { forEachFileImport } from '@stonyx/utils/file';
 import { dbKey } from './db.js';
+import { getPluralName } from './plural-registry.js';
 import log from 'stonyx/log';
 
 export default async function(route, accessPath, metaRoute) {
@@ -42,7 +43,9 @@ export default async function(route, accessPath, metaRoute) {
 
   // Configure endpoints for models with access configuration
   for (const [model, access] of Object.entries(accessFiles)) {
-    RestServer.instance.mountRoute(OrmRequest, { name, options: { model, access } }); 
+    const pluralizedModel = getPluralName(model);
+    const modelName = name === 'index' ? pluralizedModel : `${name}/${pluralizedModel}`;
+    RestServer.instance.mountRoute(OrmRequest, { name: modelName, options: { model, access } });
   }
 
   // Mount the meta route when metaRoute config is enabled