@stonyx/orm 0.2.1-alpha.15 → 0.2.1-alpha.17

package/src/main.js

@@ -37,6 +37,7 @@ export default class Orm {
   
   models = {};
   serializers = {};
+  views = {};
   transforms = { ...baseTransforms };
   warnings = new Set();
 
@@ -79,14 +80,28 @@ export default class Orm {
     // Wait for imports before db & rest server setup
     await Promise.all(promises);
 
+    // Discover views from paths.view (separate from model/serializer/transform)
+    if (paths.view) {
+      await forEachFileImport(paths.view, (exported, { name }) => {
+        const alias = `${kebabCaseToPascalCase(name)}View`;
+        Orm.store.set(name, new Map());
+        registerPluralName(name, exported);
+        this.views[alias] = exported;
+      }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
+    }
+
     // Setup event names for hooks after models are loaded
     const eventNames = [];
     const operations = ['list', 'get', 'create', 'update', 'delete'];
+    const viewOperations = ['list', 'get'];
     const timings = ['before', 'after'];
 
     for (const modelName of Orm.store.data.keys()) {
+      const isView = this.isView(modelName);
+      const ops = isView ? viewOperations : operations;
+
       for (const timing of timings) {
-        for (const operation of operations) {
+        for (const operation of ops) {
           eventNames.push(`${timing}:${operation}:${modelName}`);
         }
       }
@@ -141,13 +156,27 @@ export default class Orm {
 
   getRecordClasses(modelName) {
     const modelClassPrefix = kebabCaseToPascalCase(modelName);
-  
+
+    // Check views first, then models
+    const viewClass = this.views[`${modelClassPrefix}View`];
+    if (viewClass) {
+      return {
+        modelClass: viewClass,
+        serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
+      };
+    }
+
     return {
       modelClass: this.models[`${modelClassPrefix}Model`],
       serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
     };
   }
 
+  isView(modelName) {
+    const modelClassPrefix = kebabCaseToPascalCase(modelName);
+    return !!this.views[`${modelClassPrefix}View`];
+  }
+
   // Queue warnings to avoid the same error from being logged in the same iteration
   warn(message) {
     this.warnings.add(message);

package/src/manage-record.js

@@ -14,6 +14,11 @@ export function createRecord(modelName, rawData={}, userOptions={}) {
 
   if (!initialized && !options.isDbRecord) throw new Error('ORM is not ready');
 
+  // Guard: read-only views cannot have records created directly
+  if (orm?.isView?.(modelName) && !options.isDbRecord) {
+    throw new Error(`Cannot create records for read-only view '${modelName}'`);
+  }
+
   const modelStore = store.get(modelName);
   const globalRelationships = relationships.get('global');
   const pendingRelationships = relationships.get('pending');
@@ -83,6 +88,12 @@ export function createRecord(modelName, rawData={}, userOptions={}) {
 export function updateRecord(record, rawData, userOptions={}) {
   if (!rawData) throw new Error('rawData must be passed in to updateRecord call');
 
+  // Guard: read-only views cannot be updated
+  const modelName = record?.__model?.__name;
+  if (modelName && Orm.instance?.isView?.(modelName)) {
+    throw new Error(`Cannot update records for read-only view '${modelName}'`);
+  }
+
   const options = { ...defaultOptions, ...userOptions, update:true };
 
   record.serialize(rawData, options);

package/src/mysql/migration-generator.js

@@ -1,4 +1,4 @@
-import { introspectModels, buildTableDDL, schemasToSnapshot, getTopologicalOrder } from './schema-introspector.js';
+import { introspectModels, introspectViews, buildTableDDL, buildViewDDL, schemasToSnapshot, viewSchemasToSnapshot, getTopologicalOrder } from './schema-introspector.js';
 import { readFile, createFile, createDirectory, fileExists } from '@stonyx/utils/file';
 import path from 'path';
 import config from 'stonyx/config';
@@ -16,9 +16,18 @@ export async function generateMigration(description = 'migration') {
   const previousSnapshot = await loadLatestSnapshot(migrationsPath);
   const diff = diffSnapshots(previousSnapshot, currentSnapshot);
 
+  // Don't return early — check view changes too before deciding
   if (!diff.hasChanges) {
-    log.db('No schema changes detected.');
-    return null;
+    // Check if there are view changes before returning null
+    const viewSchemasPrelim = introspectViews();
+    const currentViewSnapshotPrelim = viewSchemasToSnapshot(viewSchemasPrelim);
+    const previousViewSnapshotPrelim = extractViewsFromSnapshot(previousSnapshot);
+    const viewDiffPrelim = diffViewSnapshots(previousViewSnapshotPrelim, currentViewSnapshotPrelim);
+
+    if (!viewDiffPrelim.hasChanges) {
+      log.db('No schema changes detected.');
+      return null;
+    }
   }
 
   const upStatements = [];
@@ -85,17 +94,71 @@ export async function generateMigration(description = 'migration') {
     downStatements.push(`ALTER TABLE \`${table}\` ADD FOREIGN KEY (\`${column}\`) REFERENCES \`${references.references}\`(\`${references.column}\`) ON DELETE SET NULL;`);
   }
 
+  // View migrations — views are created AFTER tables (dependency order)
+  const viewSchemas = introspectViews();
+  const currentViewSnapshot = viewSchemasToSnapshot(viewSchemas);
+  const previousViewSnapshot = extractViewsFromSnapshot(previousSnapshot);
+  const viewDiff = diffViewSnapshots(previousViewSnapshot, currentViewSnapshot);
+
+  if (viewDiff.hasChanges) {
+    upStatements.push('');
+    upStatements.push('-- Views');
+    downStatements.push('');
+    downStatements.push('-- Views');
+
+    // Added views
+    for (const name of viewDiff.addedViews) {
+      try {
+        const ddl = buildViewDDL(name, viewSchemas[name], schemas);
+        upStatements.push(ddl + ';');
+        downStatements.unshift(`DROP VIEW IF EXISTS \`${viewSchemas[name].viewName}\`;`);
+      } catch (error) {
+        upStatements.push(`-- WARNING: Could not generate DDL for view '${name}': ${error.message}`);
+      }
+    }
+
+    // Removed views
+    for (const name of viewDiff.removedViews) {
+      upStatements.push(`-- WARNING: View '${name}' was removed. Uncomment to drop view:`);
+      upStatements.push(`-- DROP VIEW IF EXISTS \`${previousViewSnapshot[name].viewName}\`;`);
+      downStatements.push(`-- Recreate view for removed view '${name}' manually if needed`);
+    }
+
+    // Changed views (source or aggregates changed)
+    for (const name of viewDiff.changedViews) {
+      try {
+        const ddl = buildViewDDL(name, viewSchemas[name], schemas);
+        upStatements.push(ddl + ';');
+      } catch (error) {
+        upStatements.push(`-- WARNING: Could not generate DDL for changed view '${name}': ${error.message}`);
+      }
+    }
+  }
+
+  const combinedHasChanges = diff.hasChanges || viewDiff.hasChanges;
+
+  if (!combinedHasChanges) {
+    log.db('No schema changes detected.');
+    return null;
+  }
+
+  // Merge view snapshot into the main snapshot
+  const combinedSnapshot = { ...currentSnapshot };
+  for (const [name, viewSnap] of Object.entries(currentViewSnapshot)) {
+    combinedSnapshot[name] = viewSnap;
+  }
+
   const sanitizedDescription = description.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
   const timestamp = Math.floor(Date.now() / 1000);
   const filename = `${timestamp}_${sanitizedDescription}.sql`;
   const content = `-- UP\n${upStatements.join('\n')}\n\n-- DOWN\n${downStatements.join('\n')}\n`;
 
   await createFile(path.join(migrationsPath, filename), content);
-  await createFile(path.join(migrationsPath, '.snapshot.json'), JSON.stringify(currentSnapshot, null, 2));
+  await createFile(path.join(migrationsPath, '.snapshot.json'), JSON.stringify(combinedSnapshot, null, 2));
 
   log.db(`Migration generated: ${filename}`);
 
-  return { filename, content, snapshot: currentSnapshot };
+  return { filename, content, snapshot: combinedSnapshot };
 }
 
 export async function loadLatestSnapshot(migrationsPath) {
@@ -186,3 +249,38 @@ export function detectSchemaDrift(schemas, snapshot) {
   const current = schemasToSnapshot(schemas);
   return diffSnapshots(snapshot, current);
 }
+
+export function extractViewsFromSnapshot(snapshot) {
+  const views = {};
+  for (const [name, entry] of Object.entries(snapshot)) {
+    if (entry.isView) views[name] = entry;
+  }
+  return views;
+}
+
+export function diffViewSnapshots(previous, current) {
+  const addedViews = [];
+  const removedViews = [];
+  const changedViews = [];
+
+  for (const name of Object.keys(current)) {
+    if (!previous[name]) {
+      addedViews.push(name);
+    } else if (
+      current[name].viewQuery !== previous[name].viewQuery ||
+      current[name].source !== previous[name].source
+    ) {
+      changedViews.push(name);
+    }
+  }
+
+  for (const name of Object.keys(previous)) {
+    if (!current[name]) {
+      removedViews.push(name);
+    }
+  }
+
+  const hasChanges = addedViews.length > 0 || removedViews.length > 0 || changedViews.length > 0;
+
+  return { hasChanges, addedViews, removedViews, changedViews };
+}

package/src/mysql/mysql-db.js

@@ -1,6 +1,6 @@
 import { getPool, closePool } from './connection.js';
 import { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } from './migration-runner.js';
-import { introspectModels, getTopologicalOrder, schemasToSnapshot } from './schema-introspector.js';
+import { introspectModels, introspectViews, getTopologicalOrder, schemasToSnapshot } from './schema-introspector.js';
 import { loadLatestSnapshot, detectSchemaDrift } from './migration-generator.js';
 import { buildInsert, buildUpdate, buildDelete, buildSelect } from './query-builder.js';
 import { createRecord, store } from '@stonyx/orm';
@@ -14,7 +14,7 @@ import path from 'path';
 const defaultDeps = {
   getPool, closePool, ensureMigrationsTable, getAppliedMigrations,
   getMigrationFiles, applyMigration, parseMigrationFile,
-  introspectModels, getTopologicalOrder, schemasToSnapshot,
+  introspectModels, introspectViews, getTopologicalOrder, schemasToSnapshot,
   loadLatestSnapshot, detectSchemaDrift,
   buildInsert, buildUpdate, buildDelete, buildSelect,
   createRecord, store, confirm, readFile, getPluralName, config, log, path
@@ -148,6 +148,35 @@ export default class MysqlDB {
         throw error;
       }
     }
+
+    // Load views with memory: true
+    const viewSchemas = this.deps.introspectViews();
+
+    for (const [viewName, viewSchema] of Object.entries(viewSchemas)) {
+      const { modelClass: viewClass } = Orm.instance.getRecordClasses(viewName);
+      if (viewClass?.memory !== true) {
+        this.deps.log.db(`Skipping memory load for view '${viewName}' (memory: false)`);
+        continue;
+      }
+
+      const schema = { table: viewSchema.viewName, columns: viewSchema.columns || {}, foreignKeys: viewSchema.foreignKeys || {} };
+      const { sql, values } = this.deps.buildSelect(schema.table);
+
+      try {
+        const [rows] = await this.pool.execute(sql, values);
+
+        for (const row of rows) {
+          const rawData = this._rowToRawData(row, schema);
+          this.deps.createRecord(viewName, rawData, { isDbRecord: true, serialize: false, transform: false });
+        }
+      } catch (error) {
+        if (error.code === 'ER_NO_SUCH_TABLE') {
+          this.deps.log.db(`View '${viewSchema.viewName}' does not exist yet. Skipping load for '${viewName}'.`);
+          continue;
+        }
+        throw error;
+      }
+    }
   }
 
   /**
@@ -166,7 +195,16 @@ export default class MysqlDB {
    */
   async findRecord(modelName, id) {
     const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
+    let schema = schemas[modelName];
+
+    // Check views if not found in models
+    if (!schema) {
+      const viewSchemas = this.deps.introspectViews();
+      const viewSchema = viewSchemas[modelName];
+      if (viewSchema) {
+        schema = { table: viewSchema.viewName, columns: viewSchema.columns || {}, foreignKeys: viewSchema.foreignKeys || {} };
+      }
+    }
 
     if (!schema) return undefined;
 
@@ -199,7 +237,16 @@ export default class MysqlDB {
    */
   async findAll(modelName, conditions) {
     const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
+    let schema = schemas[modelName];
+
+    // Check views if not found in models
+    if (!schema) {
+      const viewSchemas = this.deps.introspectViews();
+      const viewSchema = viewSchemas[modelName];
+      if (viewSchema) {
+        schema = { table: viewSchema.viewName, columns: viewSchema.columns || {}, foreignKeys: viewSchema.foreignKeys || {} };
+      }
+    }
 
     if (!schema) return [];
 
@@ -277,6 +324,10 @@ export default class MysqlDB {
   }
 
   async persist(operation, modelName, context, response) {
+    // Views are read-only — no-op for all write operations
+    const Orm = (await import('@stonyx/orm')).default;
+    if (Orm.instance?.isView?.(modelName)) return;
+
     switch (operation) {
       case 'create':
         return this._persistCreate(modelName, context, response);

package/src/mysql/schema-introspector.js

@@ -3,22 +3,18 @@ import { getMysqlType } from './type-map.js';
 import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from '../plural-registry.js';
 import { dbKey } from '../db.js';
+import { AggregateProperty } from '../aggregates.js';
 
 function getRelationshipInfo(property) {
   if (typeof property !== 'function') return null;
   const fnStr = property.toString();
-  const modelName = property.__relatedModelName || null;
 
-  if (fnStr.includes(`getRelationships('belongsTo',`)) return { type: 'belongsTo', modelName };
-  if (fnStr.includes(`getRelationships('hasMany',`)) return { type: 'hasMany', modelName };
+  if (fnStr.includes(`getRelationships('belongsTo',`)) return 'belongsTo';
+  if (fnStr.includes(`getRelationships('hasMany',`)) return 'hasMany';
 
   return null;
 }
 
-function sanitizeTableName(name) {
-  return name.replace(/\//g, '_');
-}
-
 export function introspectModels() {
   const { models } = Orm.instance;
   const schemas = {};
@@ -39,12 +35,12 @@ export function introspectModels() {
     for (const [key, property] of Object.entries(model)) {
       if (key.startsWith('__')) continue;
 
-      const relInfo = getRelationshipInfo(property);
+      const relType = getRelationshipInfo(property);
 
-      if (relInfo?.type === 'belongsTo') {
-        relationships.belongsTo[key] = relInfo.modelName;
-      } else if (relInfo?.type === 'hasMany') {
-        relationships.hasMany[key] = relInfo.modelName;
+      if (relType === 'belongsTo') {
+        relationships.belongsTo[key] = true;
+      } else if (relType === 'hasMany') {
+        relationships.hasMany[key] = true;
       } else if (property?.constructor?.name === 'ModelProperty') {
         if (key === 'id') {
           idType = property.type;
@@ -55,16 +51,17 @@ export function introspectModels() {
     }
 
     // Build foreign keys from belongsTo relationships
-    for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
+    for (const relName of Object.keys(relationships.belongsTo)) {
+      const modelName = camelCaseToKebabCase(relName);
       const fkColumn = `${relName}_id`;
       foreignKeys[fkColumn] = {
-        references: sanitizeTableName(getPluralName(targetModelName)),
+        references: getPluralName(modelName),
         column: 'id',
       };
     }
 
     schemas[name] = {
-      table: sanitizeTableName(getPluralName(name)),
+      table: getPluralName(name),
       idType,
       columns,
       foreignKeys,
@@ -77,8 +74,7 @@ export function introspectModels() {
 }
 
 export function buildTableDDL(name, schema, allSchemas = {}) {
-  const { idType, columns, foreignKeys } = schema;
-  const table = sanitizeTableName(schema.table);
+  const { table, idType, columns, foreignKeys } = schema;
   const lines = [];
 
   // Primary key
@@ -105,8 +101,7 @@ export function buildTableDDL(name, schema, allSchemas = {}) {
 
   // Foreign key constraints
   for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
-    const refTable = sanitizeTableName(fkDef.references);
-    lines.push(`  FOREIGN KEY (\`${fkCol}\`) REFERENCES \`${refTable}\`(\`${fkDef.column}\`) ON DELETE SET NULL`);
+    lines.push(`  FOREIGN KEY (\`${fkCol}\`) REFERENCES \`${fkDef.references}\`(\`${fkDef.column}\`) ON DELETE SET NULL`);
   }
 
   return `CREATE TABLE IF NOT EXISTS \`${table}\` (\n${lines.join(',\n')}\n)`;
@@ -136,8 +131,8 @@ export function getTopologicalOrder(schemas) {
     if (!schema) return;
 
     // Visit dependencies (belongsTo targets) first
-    for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-      visit(targetModelName);
+    for (const relName of Object.keys(schema.relationships.belongsTo)) {
+      visit(camelCaseToKebabCase(relName));
     }
 
     order.push(name);
@@ -150,6 +145,166 @@ export function getTopologicalOrder(schemas) {
   return order;
 }
 
+export function introspectViews() {
+  const orm = Orm.instance;
+  if (!orm.views) return {};
+
+  const schemas = {};
+
+  for (const [viewKey, viewClass] of Object.entries(orm.views)) {
+    const name = camelCaseToKebabCase(viewKey.slice(0, -4)); // Remove 'View' suffix
+
+    const source = viewClass.source;
+    if (!source) continue;
+
+    const model = new viewClass(name);
+    const columns = {};
+    const foreignKeys = {};
+    const aggregates = {};
+    const relationships = { belongsTo: {}, hasMany: {} };
+
+    for (const [key, property] of Object.entries(model)) {
+      if (key.startsWith('__')) continue;
+      if (key === 'id') continue;
+
+      if (property instanceof AggregateProperty) {
+        aggregates[key] = property;
+        continue;
+      }
+
+      const relType = getRelationshipInfo(property);
+
+      if (relType === 'belongsTo') {
+        relationships.belongsTo[key] = true;
+        const modelName = camelCaseToKebabCase(key);
+        const fkColumn = `${key}_id`;
+        foreignKeys[fkColumn] = {
+          references: getPluralName(modelName),
+          column: 'id',
+        };
+      } else if (relType === 'hasMany') {
+        relationships.hasMany[key] = true;
+      } else if (property?.constructor?.name === 'ModelProperty') {
+        const transforms = Orm.instance.transforms;
+        columns[key] = getMysqlType(property.type, transforms[property.type]);
+      }
+    }
+
+    schemas[name] = {
+      viewName: getPluralName(name),
+      source,
+      groupBy: viewClass.groupBy || undefined,
+      columns,
+      foreignKeys,
+      aggregates,
+      relationships,
+      isView: true,
+      memory: viewClass.memory !== false ? false : false, // Views default to memory:false
+    };
+  }
+
+  return schemas;
+}
+
+export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
+  if (!viewSchema.source) {
+    throw new Error(`View '${name}' must define a source model`);
+  }
+
+  const sourceModelName = viewSchema.source;
+  const sourceSchema = modelSchemas[sourceModelName];
+  const sourceTable = sourceSchema
+    ? sourceSchema.table
+    : getPluralName(sourceModelName);
+
+  const selectColumns = [];
+  const joins = [];
+  const hasAggregates = Object.keys(viewSchema.aggregates || {}).length > 0;
+  const groupByField = viewSchema.groupBy;
+
+  // ID column: groupBy field or source table PK
+  if (groupByField) {
+    selectColumns.push(`\`${sourceTable}\`.\`${groupByField}\` AS \`id\``);
+  } else {
+    selectColumns.push(`\`${sourceTable}\`.\`id\` AS \`id\``);
+  }
+
+  // Aggregate columns
+  for (const [key, aggProp] of Object.entries(viewSchema.aggregates || {})) {
+    if (aggProp.relationship === undefined) {
+      // Field-level aggregate (groupBy views)
+      if (aggProp.aggregateType === 'count') {
+        selectColumns.push(`COUNT(*) AS \`${key}\``);
+      } else {
+        selectColumns.push(`${aggProp.mysqlFunction}(\`${sourceTable}\`.\`${aggProp.field}\`) AS \`${key}\``);
+      }
+    } else {
+      // Relationship aggregate
+      const relName = aggProp.relationship;
+      const relModelName = camelCaseToKebabCase(relName);
+      const relTable = getPluralName(relModelName);
+
+      if (aggProp.aggregateType === 'count') {
+        selectColumns.push(`${aggProp.mysqlFunction}(\`${relTable}\`.\`id\`) AS \`${key}\``);
+      } else {
+        const field = aggProp.field;
+        selectColumns.push(`${aggProp.mysqlFunction}(\`${relTable}\`.\`${field}\`) AS \`${key}\``);
+      }
+
+      // Add LEFT JOIN for the relationship if not already added
+      const joinKey = `${relTable}`;
+      if (!joins.find(j => j.table === joinKey)) {
+        const fkColumn = `${sourceModelName}_id`;
+        joins.push({
+          table: relTable,
+          condition: `\`${relTable}\`.\`${fkColumn}\` = \`${sourceTable}\`.\`id\``
+        });
+      }
+    }
+  }
+
+  // Regular columns (from resolve map string paths or direct attr fields)
+  for (const [key, mysqlType] of Object.entries(viewSchema.columns || {})) {
+    selectColumns.push(`\`${sourceTable}\`.\`${key}\` AS \`${key}\``);
+  }
+
+  // Build JOIN clauses
+  const joinClauses = joins.map(j =>
+    `LEFT JOIN \`${j.table}\` ON ${j.condition}`
+  ).join('\n  ');
+
+  // Build GROUP BY
+  let groupBy = '';
+  if (groupByField) {
+    groupBy = `\nGROUP BY \`${sourceTable}\`.\`${groupByField}\``;
+  } else if (hasAggregates) {
+    groupBy = `\nGROUP BY \`${sourceTable}\`.\`id\``;
+  }
+
+  const viewName = viewSchema.viewName;
+  const sql = `CREATE OR REPLACE VIEW \`${viewName}\` AS\nSELECT\n  ${selectColumns.join(',\n  ')}\nFROM \`${sourceTable}\`${joinClauses ? '\n  ' + joinClauses : ''}${groupBy}`;
+
+  return sql;
+}
+
+export function viewSchemasToSnapshot(viewSchemas) {
+  const snapshot = {};
+
+  for (const [name, schema] of Object.entries(viewSchemas)) {
+    snapshot[name] = {
+      viewName: schema.viewName,
+      source: schema.source,
+      ...(schema.groupBy ? { groupBy: schema.groupBy } : {}),
+      columns: { ...schema.columns },
+      foreignKeys: { ...schema.foreignKeys },
+      isView: true,
+      viewQuery: buildViewDDL(name, schema),
+    };
+  }
+
+  return snapshot;
+}
+
 export function schemasToSnapshot(schemas) {
   const snapshot = {};
 

package/src/orm-request.js

@@ -323,21 +323,27 @@ export default class OrmRequest extends Request {
     };
 
     // Wrap handlers with hooks
+    const isView = Orm.instance?.isView?.(model);
+
     this.handlers = {
       get: {
         '/': this._withHooks('list', getCollectionHandler),
         '/:id': this._withHooks('get', getSingleHandler),
         ...this._generateRelationshipRoutes(model, pluralizedModel, modelRelationships)
       },
-      patch: {
+    };
+
+    // Views are read-only — no write endpoints
+    if (!isView) {
+      this.handlers.patch = {
         '/:id': this._withHooks('update', updateHandler)
-      },
-      post: {
+      };
+      this.handlers.post = {
         '/': this._withHooks('create', createHandler)
-      },
-      delete: {
+      };
+      this.handlers.delete = {
         '/:id': this._withHooks('delete', deleteHandler)
-      }
+      };
     }
   }
 

package/src/serializer.js

@@ -86,6 +86,13 @@ export default class Serializer {
         continue;
       }
 
+      // Aggregate property handling — use the rawData value, not the aggregate descriptor
+      if (handler?.constructor?.name === 'AggregateProperty') {
+        parsedData[key] = data;
+        record[key] = data;
+        continue;
+      }
+
       // Direct assignment handling
       if (handler?.constructor?.name !== 'ModelProperty') {
         parsedData[key] = handler;

package/src/setup-rest-server.js

@@ -41,7 +41,7 @@ export default async function(route, accessPath, metaRoute) {
   // Remove "/" prefix and name mount point accordingly
   const name = route === '/' ? 'index' : (route[0] === '/' ? route.slice(1) : route);
 
-  // Configure endpoints for models with access configuration
+  // Configure endpoints for models and views with access configuration
   for (const [model, access] of Object.entries(accessFiles)) {
     const pluralizedModel = getPluralName(model);
     const modelName = name === 'index' ? pluralizedModel : `${name}/${pluralizedModel}`;