@stonyx/orm 0.2.1-beta.2 → 0.2.1-beta.4

package/src/mysql/schema-introspector.js

@@ -0,0 +1,158 @@
+import Orm from '@stonyx/orm';
+import { getMysqlType } from './type-map.js';
+import { camelCaseToKebabCase } from '@stonyx/utils/string';
+import { pluralize } from '../utils.js';
+import { dbKey } from '../db.js';
+
+function getRelationshipInfo(property) {
+  if (typeof property !== 'function') return null;
+  const fnStr = property.toString();
+
+  if (fnStr.includes(`getRelationships('belongsTo',`)) return 'belongsTo';
+  if (fnStr.includes(`getRelationships('hasMany',`)) return 'hasMany';
+
+  return null;
+}
+
+export function introspectModels() {
+  const { models } = Orm.instance;
+  const schemas = {};
+
+  for (const [modelKey, modelClass] of Object.entries(models)) {
+    const name = camelCaseToKebabCase(modelKey.slice(0, -5));
+
+    if (name === dbKey) continue;
+
+    const model = new modelClass(modelKey);
+    const columns = {};
+    const foreignKeys = {};
+    const relationships = { belongsTo: {}, hasMany: {} };
+    let idType = 'number';
+
+    const transforms = Orm.instance.transforms;
+
+    for (const [key, property] of Object.entries(model)) {
+      if (key.startsWith('__')) continue;
+
+      const relType = getRelationshipInfo(property);
+
+      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;
+        } else {
+          columns[key] = getMysqlType(property.type, transforms[property.type]);
+        }
+      }
+    }
+
+    // Build foreign keys from belongsTo relationships
+    for (const relName of Object.keys(relationships.belongsTo)) {
+      const fkColumn = `${relName}_id`;
+      foreignKeys[fkColumn] = {
+        references: pluralize(relName),
+        column: 'id',
+      };
+    }
+
+    schemas[name] = {
+      table: pluralize(name),
+      idType,
+      columns,
+      foreignKeys,
+      relationships,
+    };
+  }
+
+  return schemas;
+}
+
+export function buildTableDDL(name, schema, allSchemas = {}) {
+  const { table, idType, columns, foreignKeys } = schema;
+  const lines = [];
+
+  // Primary key
+  if (idType === 'string') {
+    lines.push('  `id` VARCHAR(255) PRIMARY KEY');
+  } else {
+    lines.push('  `id` INT AUTO_INCREMENT PRIMARY KEY');
+  }
+
+  // Attribute columns
+  for (const [col, mysqlType] of Object.entries(columns)) {
+    lines.push(`  \`${col}\` ${mysqlType}`);
+  }
+
+  // Foreign key columns
+  for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
+    const refIdType = getReferencedIdType(fkDef.references, allSchemas);
+    lines.push(`  \`${fkCol}\` ${refIdType}`);
+  }
+
+  // Timestamps
+  lines.push('  `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP');
+  lines.push('  `updated_at` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
+
+  // Foreign key constraints
+  for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
+    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)`;
+}
+
+function getReferencedIdType(tableName, allSchemas) {
+  // Look up the referenced table's PK type from schemas
+  for (const schema of Object.values(allSchemas)) {
+    if (schema.table === tableName) {
+      return schema.idType === 'string' ? 'VARCHAR(255)' : 'INT';
+    }
+  }
+
+  // Default to INT if referenced table not found in schemas
+  return 'INT';
+}
+
+export function getTopologicalOrder(schemas) {
+  const visited = new Set();
+  const order = [];
+
+  function visit(name) {
+    if (visited.has(name)) return;
+    visited.add(name);
+
+    const schema = schemas[name];
+    if (!schema) return;
+
+    // Visit dependencies (belongsTo targets) first
+    for (const relName of Object.keys(schema.relationships.belongsTo)) {
+      visit(relName);
+    }
+
+    order.push(name);
+  }
+
+  for (const name of Object.keys(schemas)) {
+    visit(name);
+  }
+
+  return order;
+}
+
+export function schemasToSnapshot(schemas) {
+  const snapshot = {};
+
+  for (const [name, schema] of Object.entries(schemas)) {
+    snapshot[name] = {
+      table: schema.table,
+      idType: schema.idType,
+      columns: { ...schema.columns },
+      foreignKeys: { ...schema.foreignKeys },
+    };
+  }
+
+  return snapshot;
+}

package/src/mysql/type-map.js

@@ -0,0 +1,37 @@
+const typeMap = {
+  string: 'VARCHAR(255)',
+  number: 'INT',
+  float: 'FLOAT',
+  boolean: 'TINYINT(1)',
+  date: 'DATETIME',
+  timestamp: 'BIGINT',
+  passthrough: 'TEXT',
+  trim: 'VARCHAR(255)',
+  uppercase: 'VARCHAR(255)',
+  ceil: 'INT',
+  floor: 'INT',
+  round: 'INT',
+};
+
+/**
+ * Resolves a Stonyx ORM attribute type to a MySQL column type.
+ *
+ * For built-in types, returns the mapped MySQL type directly.
+ *
+ * For custom transforms (e.g. an `animal` transform that maps strings to ints):
+ *   - If the transform function exports a `mysqlType` property, that value is used.
+ *     Example: `const transform = (v) => codeMap[v]; transform.mysqlType = 'INT'; export default transform;`
+ *   - Otherwise, defaults to JSON. Values are JSON-stringified on write and
+ *     JSON-parsed on read. This handles primitives and plain objects correctly.
+ *     Class instances will be reduced to plain objects — if a custom transform
+ *     produces class instances, it must declare a `mysqlType` and handle
+ *     serialization itself.
+ */
+export function getMysqlType(attrType, transformFn) {
+  if (typeMap[attrType]) return typeMap[attrType];
+  if (transformFn?.mysqlType) return transformFn.mysqlType;
+
+  return 'JSON';
+}
+
+export default typeMap;

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 { pluralize } from './utils.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;
@@ -163,80 +213,284 @@ export default class OrmRequest extends Request {
   constructor({ model, access }) {
     super(...arguments);
 
+    this.model = model;
     this.access = access;
     const pluralizedModel = pluralize(model);
 
-    this.handlers = {
-      get: {
-        [`/${pluralizedModel}`]: (request, { filter: accessFilter }) => {
-          const allRecords = Array.from(store.get(model).values());
+    const modelRelationships = getModelRelationships(model);
 
-          const queryFilters = parseFilters(request.query);
-          const queryFilterPredicate = createFilterPredicate(queryFilters);
-          const fieldsMap = parseFields(request.query);
-          const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
+    // Define raw handlers first
+    const getCollectionHandler = (request, { filter: accessFilter }) => {
+      const allRecords = Array.from(store.get(model).values());
 
-          let recordsToReturn = allRecords;
-          if (accessFilter) recordsToReturn = recordsToReturn.filter(accessFilter);
-          if (queryFilterPredicate) recordsToReturn = recordsToReturn.filter(queryFilterPredicate);
+      const queryFilters = parseFilters(request.query);
+      const queryFilterPredicate = createFilterPredicate(queryFilters);
+      const fieldsMap = parseFields(request.query);
+      const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
 
-          const data = recordsToReturn.map(record => record.toJSON({ fields: modelFields }));
-          return buildResponse(data, request.query?.include, recordsToReturn);
-        },
+      let recordsToReturn = allRecords;
+      if (accessFilter) recordsToReturn = recordsToReturn.filter(accessFilter);
+      if (queryFilterPredicate) recordsToReturn = recordsToReturn.filter(queryFilterPredicate);
 
-        [`/${pluralizedModel}/:id`]: (request) => {
-          const record = store.get(model, getId(request.params));
-          if (!record) return 404;
+      const baseUrl = getBaseUrl(request);
+      const data = recordsToReturn.map(record => record.toJSON({ fields: modelFields, baseUrl }));
 
-          const fieldsMap = parseFields(request.query);
-          const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
+      return buildResponse(data, request.query?.include, recordsToReturn, {
+        links: { self: `${baseUrl}/${pluralizedModel}` },
+        baseUrl
+      });
+    };
 
-          return buildResponse(record.toJSON({ fields: modelFields }), request.query?.include, record);
-        }
-      },
+    const getSingleHandler = (request) => {
+      const record = store.get(model, getId(request.params));
+      if (!record) return 404;
 
-      patch: {
-        [`/${pluralizedModel}/:id`]: async ({ body, params }) => {
-          const record = store.get(model, getId(params));
-          const { attributes } = body?.data || {};
+      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
+      });
+    };
+
+    const createHandler = ({ body, query }) => {
+      const { type, id, attributes, relationships: rels } = body?.data || {};
+
+      if (!type) return 400; // Bad request
 
-          if (!attributes) return 400; // Bad request
+      const fieldsMap = parseFields(query);
+      const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
 
-          // 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;
+      // Check for duplicate ID
+      if (id !== undefined && store.get(model, id)) return 409; // Conflict
 
-            record[key] = value
-          };
+      const { id: _ignoredId, ...sanitizedAttributes } = attributes || {};
 
-          return { data: record.toJSON() };
+      // 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, query }) => {
-          const { type, attributes } = body?.data || {};
+      const recordAttributes = id !== undefined ? { id, ...sanitizedAttributes } : sanitizedAttributes;
+      const record = createRecord(model, recordAttributes, { serialize: false });
 
-          if (!type) return 400; // Bad request
+      return { data: record.toJSON({ fields: modelFields }) };
+    };
 
-          const fieldsMap = parseFields(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 updateHandler = async ({ body, params }) => {
+      const record = store.get(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({ fields: modelFields }) };
+      // 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 = store.get(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 = store.get(this.model, getId(request.params));
+      } else if (operation === 'list' && response?.data) {
+        context.records = Array.from(store.get(this.model).values());
+      } 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}`] = (request) => {
+        const record = store.get(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}`] = (request) => {
+        const record = store.get(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`] = (request) => {
+      const record = store.get(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`] = (request) => {
+      const record = store.get(model, getId(request.params));
+      if (!record) return 404;
+
+      return 404;
+    };
+
+    return routes;
   }
 
   auth(request, state) {

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 { pluralize } from './utils.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={}) {
@@ -51,8 +54,11 @@ export default class Record {
   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 { fields } = options;
+    const modelName = this.__model.__name;
+    const pluralizedModelName = pluralize(modelName);
+    const recordId = data.id;
     const relationships = {};
     const attributes = {};
 
@@ -69,19 +75,40 @@ export default class Record {
 
     for (const [key, childRecord] of Object.entries(this.__relationships)) {
       if (fields && !fields.has(key)) continue;
-      relationships[key] = {
-        data: Array.isArray(childRecord)
+
+      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={}) {