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

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.1-alpha.0",
+  "version": "0.2.5-alpha.0",
   "description": "",
   "main": "src/main.js",
   "type": "module",

package/src/orm-request.js

@@ -114,6 +114,51 @@ 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);
@@ -123,20 +168,30 @@ export default class OrmRequest extends Request {
 
     this.handlers = {
       get: {
-        [`/${pluralizedModel}`]: (request, { filter }) => {
+        [`/${pluralizedModel}`]: (request, { filter: accessFilter }) => {
           const allRecords = Array.from(store.get(model).values());
-          const recordsToReturn = filter ? allRecords.filter(filter) : allRecords;
-          const data = recordsToReturn.map(record => record.toJSON());
 
+          const queryFilters = parseFilters(request.query);
+          const queryFilterPredicate = createFilterPredicate(queryFilters);
+          const fieldsMap = parseFields(request.query);
+          const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
+
+          let recordsToReturn = allRecords;
+          if (accessFilter) recordsToReturn = recordsToReturn.filter(accessFilter);
+          if (queryFilterPredicate) recordsToReturn = recordsToReturn.filter(queryFilterPredicate);
+
+          const data = recordsToReturn.map(record => record.toJSON({ fields: modelFields }));
           return buildResponse(data, request.query?.include, recordsToReturn);
         },
 
         [`/${pluralizedModel}/:id`]: (request) => {
           const record = store.get(model, getId(request.params));
+          if (!record) return 404;
 
-          if (!record) return 404; // Record not found
+          const fieldsMap = parseFields(request.query);
+          const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
 
-          return buildResponse(record.toJSON(), request.query?.include, record);
+          return buildResponse(record.toJSON({ fields: modelFields }), request.query?.include, record);
         }
       },
 
@@ -160,14 +215,19 @@ export default class OrmRequest extends Request {
       },
 
       post: {
-        [`/${pluralizedModel}`]: ({ body }) => {
-          const { attributes } = body?.data || {};
+        [`/${pluralizedModel}`]: (request) => {
+          const { attributes } = request.body?.data || {};
 
           if (!attributes) return 400; // Bad request
 
+          const fieldsMap = parseFields(request.query);
+          const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
+          // Check for duplicate ID
+          if (attributes.id !== undefined && store.get(model, attributes.id)) return 409; // Conflict
+
           const record = createRecord(model, attributes, { serialize: false });
 
-          return { data: record.toJSON() };
+          return { data: record.toJSON({ fields: modelFields }) };
         }
       },
 

package/src/record.js

@@ -48,21 +48,29 @@ 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 { __data:data } = this;
+    const { fields } = options;
     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)) {
+    for (const [key, childRecord] of Object.entries(this.__relationships)) {
+      if (fields && !fields.has(key)) continue;
       relationships[key] = {
-        data: Array.isArray(childRecord) 
+        data: Array.isArray(childRecord)
         ? childRecord.map(r => ({ type: r.__model.__name, id: r.id }))
         : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null
       };