@stonyx/orm 0.2.1-alpha.12 → 0.2.1-alpha.13

package/src/mysql/schema-introspector.js

@@ -3,7 +3,6 @@ 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;
@@ -145,166 +144,6 @@ 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,27 +323,21 @@ 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)
       },
-    };
-
-    // Views are read-only — no write endpoints
-    if (!isView) {
-      this.handlers.patch = {
+      patch: {
         '/:id': this._withHooks('update', updateHandler)
-      };
-      this.handlers.post = {
+      },
+      post: {
         '/': this._withHooks('create', createHandler)
-      };
-      this.handlers.delete = {
+      },
+      delete: {
         '/:id': this._withHooks('delete', deleteHandler)
-      };
+      }
     }
   }
 

package/src/serializer.js

@@ -71,8 +71,8 @@ export default class Serializer {
       const handler = model[key];
       const data = query(rawData, pathPrefix, subPath);
 
-      // Ignore null/undefined values on updates (TODO: What if we want it set to null?)
-      if ((data === null || data === undefined) && options.update) continue;
+      // Skip fields not present in the update payload (undefined = not provided)
+      if (data === undefined && options.update) continue;
 
       // Relationship handling
       if (typeof handler === 'function') {
@@ -86,13 +86,6 @@ 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 and views with access configuration
+  // Configure endpoints for models with access configuration
   for (const [model, access] of Object.entries(accessFiles)) {
     const pluralizedModel = getPluralName(model);
     const modelName = name === 'index' ? pluralizedModel : `${name}/${pluralizedModel}`;

package/src/store.js

@@ -1,6 +1,5 @@
-import Orm, { relationships } from '@stonyx/orm';
+import { relationships } from '@stonyx/orm';
 import { TYPES } from './relationships.js';
-import ViewResolver from './view-resolver.js';
 
 export default class Store {
   constructor() {
@@ -29,12 +28,6 @@ export default class Store {
    * @returns {Promise<Record|undefined>}
    */
   async find(modelName, id) {
-    // For views in non-MySQL mode, use view resolver
-    if (Orm.instance?.isView?.(modelName) && !this._mysqlDb) {
-      const resolver = new ViewResolver(modelName);
-      return resolver.resolveOne(id);
-    }
-
     // For memory: true models, the store is authoritative
     if (this._isMemoryModel(modelName)) {
       return this.get(modelName, id);
@@ -57,18 +50,6 @@ export default class Store {
    * @returns {Promise<Record[]>}
    */
   async findAll(modelName, conditions) {
-    // For views in non-MySQL mode, use view resolver
-    if (Orm.instance?.isView?.(modelName) && !this._mysqlDb) {
-      const resolver = new ViewResolver(modelName);
-      const records = await resolver.resolveAll();
-
-      if (!conditions || Object.keys(conditions).length === 0) return records;
-
-      return records.filter(record =>
-        Object.entries(conditions).every(([key, value]) => record.__data[key] === value)
-      );
-    }
-
     // For memory: true models without conditions, return from store
     if (this._isMemoryModel(modelName) && !conditions) {
       const modelStore = this.get(modelName);
@@ -144,11 +125,6 @@ export default class Store {
   }
 
   remove(key, id) {
-    // Guard: read-only views cannot have records removed
-    if (Orm.instance?.isView?.(key)) {
-      throw new Error(`Cannot remove records from read-only view '${key}'`);
-    }
-
     if (id) return this.unloadRecord(key, id);
 
     this.unloadAllRecords(key);

package/.claude/views.md

@@ -1,292 +0,0 @@
-# Views
-
-Views are read-only, model-like structures that compute derived data from existing models. They work in both JSON file mode (in-memory computation) and MySQL mode (auto-generated SQL VIEWs).
-
-## What Views Are
-
-A View defines a read-only projection over source model data. Use views when you need:
-- Aggregated data (counts, averages, sums) derived from model relationships
-- Computed read-only summaries that shouldn't be persisted as separate records
-- MySQL VIEWs that are auto-generated from your JavaScript definition
-
-## Defining a View
-
-Views extend the `View` base class and are placed in the `views/` directory (configurable via `paths.view`).
-
-```javascript
-// views/owner-stats.js
-import { View, attr, belongsTo, count, avg } from '@stonyx/orm';
-
-export default class OwnerStatsView extends View {
-  static source = 'owner'; // The model whose records are iterated
-
-  animalCount = count('pets');    // COUNT of hasMany relationship
-  averageAge = avg('pets', 'age'); // AVG of a field on related records
-  owner = belongsTo('owner');     // Link back to the source record
-}
-```
-
-### File Naming
-
-- File: `owner-stats.js` → Class: `OwnerStatsView` → Store name: `'owner-stats'`
-- Directory: configured via `paths.view` (default: `'./views'`)
-- Environment variable: `ORM_VIEW_PATH`
-
-### Key Static Properties
-
-| Property | Default | Description |
-|----------|---------|-------------|
-| `source` | `undefined` | **(Required)** The model name whose records produce view records |
-| `groupBy` | `undefined` | Field name to group source records by (one view record per unique value) |
-| `resolve` | `undefined` | Optional escape-hatch map for custom derivations |
-| `memory` | `false` | `false` = computed on demand; `true` = cached on startup |
-| `readOnly` | `true` | **Enforced** — cannot be overridden to `false` |
-| `pluralName` | `undefined` | Custom plural name (same as Model) |
-
-## Aggregate Helpers
-
-Aggregate helpers define fields that compute values from related records. Each helper knows both its JavaScript computation logic and its MySQL SQL translation.
-
-| Helper | JS Behavior | MySQL Translation |
-|--------|-------------|-------------------|
-| `count(relationship)` | `relatedRecords.length` | `COUNT(table.id)` |
-| `avg(relationship, field)` | Average of field values | `AVG(table.field)` |
-| `sum(relationship, field)` | Sum of field values | `SUM(table.field)` |
-| `min(relationship, field)` | Minimum field value | `MIN(table.field)` |
-| `max(relationship, field)` | Maximum field value | `MAX(table.field)` |
-
-### Empty/Null Handling
-
-- `count` with empty/null relationship → `0`
-- `avg` with empty/null relationship → `0`
-- `sum` with empty/null relationship → `0`
-- `min` with empty/null relationship → `null`
-- `max` with empty/null relationship → `null`
-- Non-numeric values are filtered/treated as 0
-
-## Resolve Map (Escape Hatch)
-
-For computed fields that can't be expressed as aggregates, use `static resolve`:
-
-```javascript
-export default class OwnerStatsView extends View {
-  static source = 'owner';
-
-  static resolve = {
-    gender: 'gender',           // String path: maps from source record data
-    score: (owner) => {         // Function: custom computation
-      return owner.__data.age * 10;
-    },
-    nestedVal: 'details.nested', // Nested string paths supported
-  };
-
-  // Must also define as attr() for the serializer to process
-  gender = attr('string');
-  score = attr('number');
-  nestedVal = attr('passthrough');
-
-  animalCount = count('pets');
-}
-```
-
-**Important:** Each resolve map entry needs a corresponding `attr()` field definition on the view.
-
-## GroupBy Views
-
-GroupBy views produce one view record per unique value of a field on the source model, with aggregates computed within each group.
-
-### Defining a GroupBy View
-
-```javascript
-import { View, attr, count, avg, sum } from '@stonyx/orm';
-
-export default class AnimalCountBySizeView extends View {
-  static source = 'animal';
-  static groupBy = 'size';    // Group animals by their size field
-
-  id = attr('string');         // The group key becomes the id
-  animalCount = count();       // Count records in each group
-  averageAge = avg('age');     // Average of 'age' field within each group
-}
-```
-
-### Aggregate Helpers in GroupBy Views
-
-In groupBy views, aggregate helpers operate on the group's records rather than on relationships:
-
-| Helper | GroupBy Behavior | MySQL Translation |
-|--------|-----------------|-------------------|
-| `count()` | Number of records in the group | `COUNT(*)` |
-| `sum('field')` | Sum of field across group records | `SUM(source.field)` |
-| `avg('field')` | Average of field across group records | `AVG(source.field)` |
-| `min('field')` | Minimum field value in the group | `MIN(source.field)` |
-| `max('field')` | Maximum field value in the group | `MAX(source.field)` |
-
-Relationship aggregates (e.g., `count('traits')`) also work — they flatten related records across all group members and aggregate the combined set.
-
-### Resolve Map in GroupBy Views
-
-The resolve map behaves differently in groupBy views:
-- **Function resolvers** receive the **array of group records** (not a single record)
-- **String path resolvers** take the value from the **first record** in the group
-
-```javascript
-export default class LeagueStatsView extends View {
-  static source = 'game-stats';
-  static groupBy = 'competition';
-
-  static resolve = {
-    totalGoals: (groupRecords) => {
-      return groupRecords.reduce((sum, r) => {
-        const fs = r.__data.finalScore;
-        return fs ? sum + fs[0] + fs[1] : sum;
-      }, 0);
-    },
-  };
-
-  matchCount = count();
-  totalGoals = attr('number');
-}
-```
-
-### MySQL DDL for GroupBy Views
-
-```sql
-CREATE OR REPLACE VIEW `animal-count-by-sizes` AS
-SELECT
-  `animals`.`size` AS `id`,
-  COUNT(*) AS `animalCount`,
-  AVG(`animals`.`age`) AS `averageAge`
-FROM `animals`
-GROUP BY `animals`.`size`
-```
-
-## Querying Views
-
-Views use the same store API as models:
-
-```javascript
-// All view records (computed fresh each call in JSON mode)
-const stats = await store.findAll('owner-stats');
-
-// Single view record by source ID
-const stat = await store.find('owner-stats', ownerId);
-
-// With conditions
-const filtered = await store.findAll('owner-stats', { animalCount: 5 });
-```
-
-## Read-Only Enforcement
-
-Views are strictly read-only at all layers:
-
-```javascript
-// All of these throw errors:
-createRecord('owner-stats', data);        // Error: Cannot create records for read-only view
-updateRecord(viewRecord, data);            // Error: Cannot update records for read-only view
-store.remove('owner-stats', id);           // Error: Cannot remove records from read-only view
-
-// Internal use only — bypasses guard:
-createRecord('owner-stats', data, { isDbRecord: true }); // Used by resolver/loader
-```
-
-## REST API Behavior
-
-When a view is included in an access configuration, only GET endpoints are mounted:
-
-- `GET /view-plural-name` — Returns list of view records
-- `GET /view-plural-name/:id` — Returns single view record
-- `GET /view-plural-name/:id/{relationship}` — Related resources
-- No POST, PATCH, DELETE endpoints
-
-## JSON Mode (In-Memory Resolver)
-
-In JSON/non-MySQL mode, the ViewResolver:
-
-1. Iterates all records of the `source` model from the store
-2. For each source record:
-   - Computes aggregate properties from relationships
-   - Applies resolve map entries (string paths or functions)
-   - Maps regular attr fields from source data
-3. Creates view records via `createRecord` with `isDbRecord: true`
-4. Returns computed array
-
-## MySQL Mode
-
-In MySQL mode:
-
-1. **Schema introspection** generates VIEW metadata via `introspectViews()`
-2. **DDL generation** creates `CREATE OR REPLACE VIEW` SQL from aggregates and relationships
-3. **Queries** use `SELECT * FROM \`view_name\`` just like tables
-4. **Migrations** include `CREATE OR REPLACE VIEW` after table statements
-5. **persist()** is a no-op for views
-6. **loadMemoryRecords()** loads views with `memory: true` from the MySQL VIEW
-
-### Generated SQL Example
-
-For `OwnerStatsView` with `count('pets')` and `avg('pets', 'age')`:
-
-```sql
-CREATE OR REPLACE VIEW `owner-stats` AS
-SELECT
-  `owners`.`id` AS `id`,
-  COUNT(`animals`.`id`) AS `animalCount`,
-  AVG(`animals`.`age`) AS `avgAge`
-FROM `owners`
-  LEFT JOIN `animals` ON `animals`.`owner_id` = `owners`.`id`
-GROUP BY `owners`.`id`
-```
-
-## Migration Support
-
-Views are handled in migrations alongside tables:
-
-- **Added views** → `CREATE OR REPLACE VIEW ...` in UP, `DROP VIEW IF EXISTS ...` in DOWN
-- **Removed views** → Commented `DROP VIEW` warning in UP (matching model removal pattern)
-- **Changed views** → `CREATE OR REPLACE VIEW ...` in UP (replaces automatically)
-- Views appear AFTER table statements in migrations (dependency order)
-- Snapshots include view entries with `isView: true` and `viewQuery`
-
-## Memory Flag
-
-- `static memory = false` (default) — View records are computed fresh on each query
-- `static memory = true` — View records are loaded from MySQL VIEW on startup and cached
-
-## Testing Views
-
-```javascript
-import QUnit from 'qunit';
-import { store } from '@stonyx/orm';
-
-QUnit.test('view returns computed data', async function(assert) {
-  // Create source data
-  createRecord('owner', { id: 1, name: 'Alice' }, { serialize: false });
-  createRecord('animal', { id: 1, age: 3, owner: 1 }, { serialize: false });
-
-  // Query the view
-  const results = await store.findAll('owner-stats');
-  const stat = results.find(r => r.id === 1);
-
-  assert.strictEqual(stat.__data.animalCount, 1);
-});
-```
-
-## Architecture
-
-### Source Files
-
-| File | Purpose |
-|------|---------|
-| `src/view.js` | View base class |
-| `src/aggregates.js` | AggregateProperty class + helper functions |
-| `src/view-resolver.js` | In-memory view resolver |
-| `src/mysql/schema-introspector.js` | `introspectViews()`, `buildViewDDL()` |
-| `src/mysql/migration-generator.js` | `diffViewSnapshots()`, view migration generation |
-
-### Key Design Decisions
-
-1. **View does NOT extend Model** — conceptually separate; shared behavior is minimal
-2. **Driver-agnostic API** — No SQL in view definitions; MySQL driver generates SQL automatically
-3. **Aggregate helpers follow the transform pattern** — Each knows both JS computation and MySQL mapping
-4. **Resolve map mirrors Serializer.map** — String paths or function resolvers
-5. **View schemas are separate** — `introspectViews()` is separate from `introspectModels()`

package/src/aggregates.js

@@ -1,93 +0,0 @@
-export class AggregateProperty {
-  constructor(aggregateType, relationship, field) {
-    this.aggregateType = aggregateType;
-    this.relationship = relationship;
-    this.field = field;
-    this.mysqlFunction = aggregateType.toUpperCase();
-    this.resultType = aggregateType === 'avg' ? 'float' : 'number';
-  }
-
-  compute(relatedRecords) {
-    if (!relatedRecords || !Array.isArray(relatedRecords) || relatedRecords.length === 0) {
-      if (this.aggregateType === 'min' || this.aggregateType === 'max') return null;
-      return 0;
-    }
-
-    switch (this.aggregateType) {
-      case 'count':
-        return relatedRecords.length;
-
-      case 'sum':
-        return relatedRecords.reduce((acc, record) => {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
-          return acc + (isNaN(val) ? 0 : val);
-        }, 0);
-
-      case 'avg': {
-        let sum = 0;
-        let count = 0;
-        for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
-          if (!isNaN(val)) {
-            sum += val;
-            count++;
-          }
-        }
-        return count === 0 ? 0 : sum / count;
-      }
-
-      case 'min': {
-        let min = null;
-        for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
-          if (!isNaN(val) && (min === null || val < min)) min = val;
-        }
-        return min;
-      }
-
-      case 'max': {
-        let max = null;
-        for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
-          if (!isNaN(val) && (max === null || val > max)) max = val;
-        }
-        return max;
-      }
-
-      default:
-        return null;
-    }
-  }
-}
-
-export function count(relationship) {
-  return new AggregateProperty('count', relationship);
-}
-
-export function avg(relationshipOrField, field) {
-  if (field !== undefined) {
-    return new AggregateProperty('avg', relationshipOrField, field);
-  }
-  return new AggregateProperty('avg', undefined, relationshipOrField);
-}
-
-export function sum(relationshipOrField, field) {
-  if (field !== undefined) {
-    return new AggregateProperty('sum', relationshipOrField, field);
-  }
-  return new AggregateProperty('sum', undefined, relationshipOrField);
-}
-
-export function min(relationshipOrField, field) {
-  if (field !== undefined) {
-    return new AggregateProperty('min', relationshipOrField, field);
-  }
-  return new AggregateProperty('min', undefined, relationshipOrField);
-}
-
-export function max(relationshipOrField, field) {
-  if (field !== undefined) {
-    return new AggregateProperty('max', relationshipOrField, field);
-  }
-  return new AggregateProperty('max', undefined, relationshipOrField);
-}