@stonyx/orm 0.2.5-alpha.0 → 0.3.1

package/src/orm-request.js

@@ -1,249 +0,0 @@
-import { Request } from '@stonyx/rest-server';
-import { createRecord, store } from '@stonyx/orm';
-import { pluralize } from '@stonyx/utils/string';
-
-const methodAccessMap = {
-  GET: 'read',
-  POST: 'create',
-  DELETE: 'delete',
-  PATCH: 'update',
-};
-
-function getId({ id }) {
-  if (isNaN(id)) return id;
-
-  return parseInt(id);
-}
-
-function buildResponse(data, includeParam, recordOrRecords) {
-  const response = { data };
-
-  if (!includeParam) return response;
-
-  const includes = parseInclude(includeParam);
-  if (includes.length === 0) return response;
-
-  const includedRecords = collectIncludedRecords(recordOrRecords, includes);
-  if (includedRecords.length > 0) {
-    response.included = includedRecords.map(record => record.toJSON());
-  }
-
-  return response;
-}
-
-/**
- * Recursively traverse an include path and collect related records
- * @param {Array<Record>} currentRecords - Records to process at current depth
- * @param {Array<string>} includePath - Full path array (e.g., ['owner', 'pets', 'traits'])
- * @param {number} depth - Current depth in the path
- * @param {Map} seen - Deduplication map
- * @param {Array} included - Accumulator for included records
- */
-function traverseIncludePath(currentRecords, includePath, depth, seen, included) {
-  if (depth >= includePath.length) return; // Reached end of path
-
-  const relationshipName = includePath[depth];
-  const nextRecords = [];
-
-  for (const record of currentRecords) {
-    if (!record.__relationships) continue;
-    if (!(relationshipName in record.__relationships)) continue;
-
-    const relatedRecords = record.__relationships[relationshipName];
-    if (!relatedRecords) continue;
-
-    // Handle both belongsTo (single) and hasMany (array)
-    const recordsToProcess = Array.isArray(relatedRecords)
-      ? relatedRecords
-      : [relatedRecords];
-
-    for (const relatedRecord of recordsToProcess) {
-      if (!relatedRecord) continue;
-
-      const type = relatedRecord.__model.__name;
-      const id = relatedRecord.id;
-
-      // Initialize Set for this type if needed
-      if (!seen.has(type)) {
-        seen.set(type, new Set());
-      }
-
-      // Check if we've already seen this type+id combination
-      if (!seen.get(type).has(id)) {
-        seen.get(type).add(id);
-        included.push(relatedRecord);
-        nextRecords.push(relatedRecord); // Prepare for next depth level
-      } else if (depth < includePath.length - 1) {
-        // Even if we've seen this record, we might need it for deeper traversal
-        nextRecords.push(relatedRecord);
-      }
-    }
-  }
-
-  // If there are more segments in the path, recursively process
-  if (depth < includePath.length - 1 && nextRecords.length > 0) {
-    traverseIncludePath(nextRecords, includePath, depth + 1, seen, included);
-  }
-}
-
-function collectIncludedRecords(data, includes) {
-  if (!includes || includes.length === 0) return [];
-  if (!data) return [];
-
-  const seen = new Map(); // Map<type, Set<id>> for deduplication
-  const included = [];
-
-  // Normalize to array for consistent processing
-  const records = Array.isArray(data) ? data : [data];
-
-  // Process each include path
-  for (const includePath of includes) {
-    traverseIncludePath(records, includePath, 0, seen, included);
-  }
-
-  return included;
-}
-
-function parseInclude(includeParam) {
-  if (!includeParam || typeof includeParam !== 'string') return [];
-
-  return includeParam
-    .split(',')
-    .map(rel => rel.trim())
-    .filter(rel => rel.length > 0)
-    .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.access = access;
-    const pluralizedModel = pluralize(model);
-
-    this.handlers = {
-      get: {
-        [`/${pluralizedModel}`]: (request, { filter: accessFilter }) => {
-          const allRecords = Array.from(store.get(model).values());
-
-          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;
-
-          const fieldsMap = parseFields(request.query);
-          const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
-
-          return buildResponse(record.toJSON({ fields: modelFields }), request.query?.include, record);
-        }
-      },
-
-      patch: {
-        [`/${pluralizedModel}/:id`]: async ({ body, params }) => {
-          const record = store.get(model, getId(params));
-          const { attributes } = body?.data || {};
-
-          if (!attributes) return 400; // Bad request
-
-          // 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;
-
-            record[key] = value
-          };
-
-          return { data: record.toJSON() };
-        }
-      },
-
-      post: {
-        [`/${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({ fields: modelFields }) };
-        }
-      },
-
-      delete: {
-        [`/${pluralizedModel}/:id`]: ({ params }) => {
-          store.remove(model, getId(params));
-        }
-      }
-    }
-  }
-
-  auth(request, state) {
-    const access = this.access(request);
-
-    if (!access) return 403;
-    if (Array.isArray(access) && !access.includes(methodAccessMap[request.method])) return 403;
-    if (typeof access === 'function') state.filter = access;
-  }
-}

package/src/record.js

@@ -1,100 +0,0 @@
-import { store } from './index.js';
-import { getComputedProperties } from "./serializer.js";
-export default class Record {
-  __data = {};
-  __relationships = {};
-  __serialized = false;
-
-  constructor(model, serializer) {
-    this.__model = model;
-    this.__serializer = serializer;
-  }
-
-  serialize(rawData, options={}) {
-    const { __data:data } = this;
-    
-    if (this.__serialized && !options.update) {
-      const relatedIds = {};
-
-      for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-        relatedIds[key] = Array.isArray(childRecord) 
-        ? childRecord.map(r => r.id)
-        : childRecord?.id ?? null;
-      }
-
-      return { ...data, ...relatedIds };
-    }
-
-    const normalizedData = this.__serializer.normalize(rawData);
-    this.__serializer.setProperties(normalizedData, this, options);
-
-    return data;
-  }
-
-  // Similar to serialize, but preserves top level relationship records
-  format() {
-    if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
-    
-    const { __data:data } = this;
-    const records = {};
-
-    for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-      records[key] = Array.isArray(childRecord) 
-      ? childRecord.map(r => r.serialize())
-      : childRecord?.serialize() ?? null;
-    }
-
-    return { ...data, ...records };
-  }
-
-  // Formats record for JSON API output
-  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 = {};
-
-    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)) {
-      if (fields && !fields.has(key)) continue;
-      relationships[key] = {
-        data: Array.isArray(childRecord)
-        ? childRecord.map(r => ({ type: r.__model.__name, id: r.id }))
-        : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null
-      };
-    }
-
-    return {
-      attributes,
-      relationships,
-      id: data.id,
-      type: this.__model.__name,
-    };
-  }
-
-  unload(options={}) {
-    store.unloadRecord(this.__model.__name, this.id, options);
-  }
-
-  clean() {
-    try {
-      for (const key of Object.keys(this)) {
-        delete this[key];
-      }
-    } catch {
-      // Ignore errors during cleanup, as some keys may not be deletable
-    }
-  }
-}

package/src/relationships.js

@@ -1,43 +0,0 @@
-import { relationships } from "@stonyx/orm";
-
-export default class Relationships {
-  constructor() {
-    if (Relationships.instance) return Relationships.instance;
-    Relationships.instance = this;
-
-    this.data = new Map();
-  }
-
-  get(key) {
-    return this.data.get(key);
-  }
-
-  set(key, value) {
-    this.data.set(key, value);
-  }
-}
-
-// TODO: Refactor mapping to remove a level of iteration
-export function getRelationships(type, sourceModel, targetModel, relationshipId) {
-  const allRelationships = relationships.get(type);
-  
-  // create relationship map for this type of it doesn't already exist
-  if (!allRelationships.has(sourceModel)) allRelationships.set(sourceModel, new Map());
-  
-  const modelRelationship = allRelationships.get(sourceModel);
-
-  if (!modelRelationship.has(targetModel)) modelRelationship.set(targetModel, new Map());
-
-  const relationship = modelRelationship.get(targetModel);
-
-  // TODO: Determine whether already having id should be handled differently
-  //if (relationship.has(relationshipId)) return;
-
-  return relationship;
-}
-
-export function getHasManyRelationships(sourceModel, targetModel) {
-  return relationships.get('hasMany').get(sourceModel)?.get(targetModel);
-}
-
-export const TYPES = ['global', 'hasMany', 'belongsTo', 'pending'];

package/src/serializer.js

@@ -1,138 +0,0 @@
-import config from 'stonyx/config';
-import { get, makeArray } from '@stonyx/utils/object';
-
-const RESERVED_KEYS = ['__name'];
-
-function searchQuery(query, array, key) {
-  const result = makeArray(array).find(item => {
-    for (const [ prop, value ] of Object.entries(query)) {
-      if (item[prop] !== value) return false;
-
-      return true;
-    }
-  });
-
-  if (!result) return null;
-  if (key) return result[key];
-
-  return result;
-}
-
-function query(rawData, pathPrefix, subPath) {
-  if (!rawData) return null;
-
-  const [ path, getter, pointer ] = makeArray(subPath);
-  const fullPath = `${pathPrefix}${path}`;
-  const value = get(rawData, fullPath);
-
-  if (getter === undefined || getter === null) return value;
-
-  try {
-    switch(typeof getter) {
-      case 'object':
-        return searchQuery(getter, value, pointer);
-
-      case 'function':
-        return getter(value);
-
-      case 'number':
-        const element = value[getter];
-        return pointer ? element[pointer] : element;
-
-      default: 
-        return value[getter];
-    }
-  } catch (error) {
-    if (config.debug) console.error(`Cannot parse value for ${fullPath}.`, { getter, query }, error);
-  }
-}
-
-export default class Serializer {
-  map = {};
-  path = '';
-
-  constructor(model) {
-    this.model = model;
-  }
-
-  /**
-   * This method populates the record's instance with instances of
-   * the ModelProperty object, while setting parsed values to the record's
-   * __data property, which represents the serialized version of the data
-   */
-  setProperties(rawData, record, options) {
-    const { path, model } = this;
-    const keys = Object.keys(model).filter(key => !RESERVED_KEYS.includes(key));
-    const pathPrefix = path ? `${path}.` : '';
-    const { __data:parsedData, __relationships:relatedRecords } = record;
-
-    for (const key of keys) {
-      const subPath = options.serialize ? (this.map[key] || key) : key;
-      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;
-
-      // Relationship handling
-      if (typeof handler === 'function') {
-        // Pass relationship key name to handler for pending fulfillment
-        const handlerOptions = { ...options, _relationshipKey: key };
-        const childRecord = handler(record, data, handlerOptions);
-
-        record[key] = childRecord
-        relatedRecords[key] = childRecord;
-
-        continue;
-      }
-
-      // Direct assignment handling
-      if (handler?.constructor?.name !== 'ModelProperty') {
-        parsedData[key] = handler;
-        record[key] = handler;
-        continue;
-      }
-
-      Object.defineProperty(record, key, {
-        enumerable: true,
-        configurable: true,
-        get: () => handler.value,
-        set(newValue) {
-          handler.ignoreFirstTransform = !options.transform;
-          handler.value = newValue;
-          parsedData[key] = handler.value;
-        }
-      });
-
-      record[key] = data;
-    }
-
-    if (options.update) return;
-
-    // Serialize computed properties
-    for (const [key, getter] of getComputedProperties(this.model)) {
-      Object.defineProperty(record, key, {
-        enumerable: true,
-        get: () => getter.call(record)
-      });
-    }
-
-    record.__serialized = true;
-  }
-
-  /**
-   * OVERRIDE: This hook allows for data manipulation prior to serialization logic
-   */
-  normalize(data) {
-    return data;
-  }
-}
-
-export function getComputedProperties(classInstance) {
-  const proto = Object.getPrototypeOf(classInstance);
-  if (!proto || proto === Object.prototype) return [];
-  
-  return Object.entries(Object.getOwnPropertyDescriptors(proto))
-    .filter(([key, descriptor]) => key !== 'constructor' && descriptor.get)
-    .map(([key, descriptor]) => [key, descriptor.get]);
-}

package/src/setup-rest-server.js

@@ -1,57 +0,0 @@
-import { waitForModule } from 'stonyx';
-import { store } from '@stonyx/orm';
-import OrmRequest from './orm-request.js';
-import MetaRequest from './meta-request.js';
-import RestServer from '@stonyx/rest-server';
-import { forEachFileImport } from '@stonyx/utils/file';
-import { dbKey } from './db.js';
-import log from 'stonyx/log';
-
-export default async function(route, accessPath, metaRoute) {
-  let accessFiles = {};
-  
-  try {
-    await forEachFileImport(accessPath, accessClass => {
-      const accessInstance = new accessClass();
-      const { models } = accessInstance;
-
-      if (!models) throw new Error(`Access class "${accessClass.name}" must define a "models" list`);
-
-      if (models.length === 0) return; // No models to assign access to
-      if (typeof accessInstance.access !== 'function') throw new Error(`Access class "${accessClass.name}" must declare an "access" method`);
-
-      const availableModels = Array.from(store.data.keys());
-
-      for (const model of models === '*' ? availableModels : models) {
-        if (model === dbKey) continue;
-        if (!store.data.has(model)) throw new Error(`Unable to define access for Invalid Model "${model}". Model does not exist`);
-        if (accessFiles[model]) throw new Error(`Access for model "${model}" has already been defined by another access class.`);
-
-        accessFiles[model] = accessInstance.access;
-      }
-    });
-  } catch (error) {
-    log.error(error.message);
-    log.warn('You must define a valid access configuration file in order to access ORM generated REST endpoints.');
-  }
-
-  await waitForModule('rest-server');
-
-  // Remove "/" prefix and name mount point accordingly
-  const name = route === '/' ? 'index' : (route[0] === '/' ? route.slice(1) : route);
-
-  // Configure endpoints for models with access configuration
-  for (const [model, access] of Object.entries(accessFiles)) {
-    RestServer.instance.mountRoute(OrmRequest, { name, options: { model, access } }); 
-  }
-
-  // Mount the meta route when metaRoute config is enabled
-  if (metaRoute) {
-    log.warn('SECURITY RISK! - Meta route is enabled via metaRoute config. This feature is intended for development purposes only!');
-
-    RestServer.instance.mountRoute(MetaRequest, { name });
-  }
-
-  // Cleanup references
-  accessFiles = null;
-}