@stonyx/orm 0.2.1-alpha.4 → 0.2.1-alpha.40

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/undefined values on updates (TODO: What if we want it set to null?)
-      if ((data === null || data === undefined) && 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/store.js

@@ -1,316 +0,0 @@
-import { relationships } from '@stonyx/orm';
-import { TYPES } from './relationships.js';
-
-export default class Store {
-  constructor() {
-    if (Store.instance) return Store.instance;
-    Store.instance = this;
-
-    this.data = new Map();
-  }
-
-  /**
-   * Synchronous memory-only access.
-   * Returns the record if it exists in the in-memory store, undefined otherwise.
-   * Does NOT query the database. For memory:false models, use find() instead.
-   */
-  get(key, id) {
-    if (!id) return this.data.get(key);
-
-    return this.data.get(key)?.get(id);
-  }
-
-  /**
-   * Async authoritative read. Always queries MySQL for memory: false models.
-   * For memory: true models, returns from store (already loaded on boot).
-   * @param {string} modelName - The model name
-   * @param {string|number} id - The record ID
-   * @returns {Promise<Record|undefined>}
-   */
-  async find(modelName, id) {
-    // For memory: true models, the store is authoritative
-    if (this._isMemoryModel(modelName)) {
-      return this.get(modelName, id);
-    }
-
-    // For memory: false models, always query MySQL
-    if (this._mysqlDb) {
-      return this._mysqlDb.findRecord(modelName, id);
-    }
-
-    // Fallback to store (JSON mode or no MySQL)
-    return this.get(modelName, id);
-  }
-
-  /**
-   * Async read for all records of a model. Always queries MySQL for memory: false models.
-   * For memory: true models, returns from store.
-   * @param {string} modelName - The model name
-   * @param {Object} [conditions] - Optional WHERE conditions
-   * @returns {Promise<Record[]>}
-   */
-  async findAll(modelName, conditions) {
-    // For memory: true models without conditions, return from store
-    if (this._isMemoryModel(modelName) && !conditions) {
-      const modelStore = this.get(modelName);
-      return modelStore ? Array.from(modelStore.values()) : [];
-    }
-
-    // For memory: false models (or filtered queries), always query MySQL
-    if (this._mysqlDb) {
-      return this._mysqlDb.findAll(modelName, conditions);
-    }
-
-    // Fallback to store (JSON mode) — apply conditions in-memory if provided
-    const modelStore = this.get(modelName);
-    if (!modelStore) return [];
-
-    const records = Array.from(modelStore.values());
-
-    if (!conditions || Object.keys(conditions).length === 0) return records;
-
-    return records.filter(record =>
-      Object.entries(conditions).every(([key, value]) => record.__data[key] === value)
-    );
-  }
-
-  /**
-   * Async query — always hits MySQL, never reads from memory cache.
-   * Use for complex queries, aggregations, or when you need guaranteed freshness.
-   * @param {string} modelName - The model name
-   * @param {Object} conditions - WHERE conditions
-   * @returns {Promise<Record[]>}
-   */
-  async query(modelName, conditions = {}) {
-    if (this._mysqlDb) {
-      return this._mysqlDb.findAll(modelName, conditions);
-    }
-
-    // Fallback: filter in-memory store
-    const modelStore = this.get(modelName);
-    if (!modelStore) return [];
-
-    const records = Array.from(modelStore.values());
-
-    if (Object.keys(conditions).length === 0) return records;
-
-    return records.filter(record =>
-      Object.entries(conditions).every(([key, value]) => record.__data[key] === value)
-    );
-  }
-
-  /**
-   * Set by Orm during init — resolves memory flag for a model name.
-   * @type {Function|null}
-   */
-  _memoryResolver = null;
-
-  /**
-   * Set by Orm during init — reference to the MysqlDB instance for on-demand queries.
-   * @type {MysqlDB|null}
-   */
-  _mysqlDb = null;
-
-  /**
-   * Check if a model is configured for in-memory storage.
-   * @private
-   */
-  _isMemoryModel(modelName) {
-    if (this._memoryResolver) return this._memoryResolver(modelName);
-    return true; // default to memory if resolver not set yet
-  }
-
-  set(key, value) {
-    this.data.set(key, value);
-  }
-
-  remove(key, id) {
-    if (id) return this.unloadRecord(key, id);
-
-    this.unloadAllRecords(key);
-  }
-
-  unloadRecord(model, id, options={}) {
-    const modelStore = this.data.get(model);
-
-    if (!modelStore) {
-      console.warn(`[Store] Cannot unload record: model "${model}" not found in store`);
-      return;
-    }
-
-    const record = modelStore.get(id);
-
-    if (!record) {
-      console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store`);
-      return;
-    }
-
-    const { toUnload, visited } = options.includeChildren
-      ? this._buildUnloadQueue(record, options)
-      : { toUnload: [{ record, modelName: model, recordId: id }], visited: new Set([`${model}:${id}`]) };
-
-    for (const item of toUnload.reverse()) {
-      const { record: recordToUnload, modelName, recordId } = item;
-
-      this._removeFromHasManyArrays(modelName, recordId, visited);
-      this._nullifyBelongsToReferences(modelName, recordId, visited);
-      this._cleanupRelationshipRegistries(modelName, recordId);
-      recordToUnload.clean();
-
-      this.data.get(modelName).delete(recordId);
-    }
-  }
-
-  unloadAllRecords(model, options={}) {
-    const modelStore = this.data.get(model);
-
-    if (!modelStore) {
-      console.warn(`[Store] Cannot unload all records: model "${model}" not found in store`);
-      return;
-    }
-
-    const recordIds = Array.from(modelStore.keys());
-
-    for (const id of recordIds) {
-      if (modelStore.has(id)) {
-        this.unloadRecord(model, id, options);
-      }
-    }
-
-    for (const relationshipType of TYPES) relationships.get(relationshipType).delete(model);
-  }
-
-  _removeFromHasManyArrays(modelName, recordId, visited) {
-    const hasManyRegistry = relationships.get('hasMany');
-
-    for (const [sourceModel, targetModels] of hasManyRegistry) {
-      const targetModelMap = targetModels.get(modelName);
-      if (!targetModelMap) continue;
-
-      for (const [sourceRecordId, hasManyArray] of targetModelMap) {
-        const sourceKey = `${sourceModel}:${sourceRecordId}`;
-
-        // Don't modify arrays of records being deleted
-        if (visited.has(sourceKey)) continue;
-
-        const index = hasManyArray.findIndex(r => r && r.id === recordId);
-        if (index !== -1) hasManyArray.splice(index, 1);
-      }
-    }
-  }
-
-  _nullifyBelongsToReferences(modelName, recordId, visited) {
-    const belongsToRegistry = relationships.get('belongsTo');
-
-    for (const [sourceModel, targetModels] of belongsToRegistry) {
-      const targetModelMap = targetModels.get(modelName);
-      if (!targetModelMap) continue;
-
-      for (const [sourceRecordId, belongsToRecord] of targetModelMap) {
-        if (belongsToRecord && belongsToRecord.id === recordId) {
-          const sourceKey = `${sourceModel}:${sourceRecordId}`;
-
-          if (visited.has(sourceKey)) continue;
-          targetModelMap.set(sourceRecordId, null);
-
-          const sourceRecord = this.get(sourceModel, sourceRecordId);
-          if (sourceRecord && sourceRecord.__relationships) {
-            for (const [key, value] of Object.entries(sourceRecord.__relationships)) {
-              if (value && value.id === recordId) {
-                sourceRecord.__relationships[key] = null;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  _cleanupRelationshipRegistries(modelName, recordId) {
-    const hasManyMap = relationships.get('hasMany').get(modelName);
-    if (hasManyMap) {
-      for (const [, recordMap] of hasManyMap) recordMap.delete(recordId);
-    }
-
-    const belongsToMap = relationships.get('belongsTo').get(modelName);
-    if (belongsToMap) {
-      for (const [, recordMap] of belongsToMap) recordMap.delete(recordId);
-    }
-
-    const pendingMap = relationships.get('pending').get(modelName);
-    if (pendingMap) pendingMap.delete(recordId);
-  }
-
-  /**
-   * Extracts hasMany and non-bidirectional belongsTo children from a record
-   * @private
-   */
-  _getChildren(record) {
-    const children = [];
-
-    if (!record.__relationships) return children;
-
-    for (const [key, value] of Object.entries(record.__relationships)) {
-      // hasMany children - always include
-      if (Array.isArray(value)) {
-        for (const childRecord of value) {
-          if (childRecord) children.push({ childRecord, relationshipKey: key, type: 'hasMany' });
-        }
-      } else if (value && !this._isBidirectionalRelationship(
-        record.__model.__name,
-        value.__model.__name
-      )) {
-        children.push({ childRecord: value, relationshipKey: key, type: 'belongsTo' });
-      }
-    }
-
-    return children;
-  }
-
-  _isBidirectionalRelationship(sourceModel, targetModel) {
-    const hasManyRegistry = relationships.get('hasMany');
-    const inverseMap = hasManyRegistry.get(targetModel)?.get(sourceModel);
-
-    return inverseMap && inverseMap.size > 0;
-  }
-
-  _buildUnloadQueue(record, options) {
-    const visited = new Set();
-    const toUnload = [];
-    const queue = [{
-      record,
-      modelName: record.__model.__name,
-      recordId: record.id,
-      isRoot: true,
-      depth: 0
-    }];
-
-    while (queue.length > 0) {
-      const item = queue.shift();
-      const key = `${item.modelName}:${item.recordId}`;
-
-      if (visited.has(key)) continue;
-      visited.add(key);
-
-      toUnload.push(item);
-
-      // Add children to queue if includeChildren is enabled
-      if (options.includeChildren) {
-        const children = this._getChildren(item.record);
-        for (const { childRecord } of children) {
-          if (childRecord) {
-            queue.push({
-              record: childRecord,
-              modelName: childRecord.__model.__name,
-              recordId: childRecord.id,
-              isRoot: false,
-              depth: item.depth + 1
-            });
-          }
-        }
-      }
-    }
-
-    return { toUnload, visited };
-  }
-}

package/src/transforms.js

@@ -1,20 +0,0 @@
-import { getTimestamp } from "@stonyx/utils/date";
-
-const transforms = {
-  boolean: value => typeof value === 'string' ? value.trim().toLowerCase() === 'true' : !!value,
-  date: value => value ? new Date(value) : null,
-  float: value => parseFloat(value),
-  number: value => parseInt(value),
-  passthrough: value => value,
-  string: value => String(value),
-  timestamp: value => getTimestamp(value),
-  trim: value => value?.trim(),
-  uppercase: value => value?.toUpperCase(),
-};
-
-// Math Proxies
-['ceil', 'floor', 'round'].forEach(method => {
-  transforms[method] = value => Math[method](value);
-});
-
-export default transforms;

package/src/utils.js

@@ -1,12 +0,0 @@
-import { pluralize as basePluralize } from '@stonyx/utils/string';
-
-// Wrapper to handle dasherized model names (e.g., "access-link" → "access-links")
-export function pluralize(word) {
-  if (word.includes('-')) {
-    const parts = word.split('-');
-    const pluralizedLast = basePluralize(parts.pop());
-    return [...parts, pluralizedLast].join('-');
-  }
-
-  return basePluralize(word);
-}

package/test-events-setup.js

@@ -1,41 +0,0 @@
-/**
- * Debug script to verify event setup
- */
-
-import Stonyx from 'stonyx';
-import config from './config/environment.js';
-import Orm from './src/main.js';
-import { subscribe } from '@stonyx/events';
-
-// Override paths for tests
-Object.assign(config.paths, {
-  access: './test/sample/access',
-  model: './test/sample/models',
-  serializer: './test/sample/serializers',
-  transform: './test/sample/transforms'
-});
-
-// Override db settings for tests
-Object.assign(config.db, {
-  file: './test/sample/db.json',
-  schema: './test/sample/db-schema.js'
-});
-
-new Stonyx(config, import.meta.dirname);
-
-const orm = new Orm();
-await orm.init();
-
-console.log('ORM initialized');
-console.log('Store keys:', Array.from(Orm.store.data.keys()));
-
-// Try subscribing to an event
-try {
-  const unsubscribe = subscribe('before:create:animal', (context) => {
-    console.log('Hook called!', context);
-  });
-  console.log('✓ Successfully subscribed to before:create:animal');
-  unsubscribe();
-} catch (error) {
-  console.error('✗ Failed to subscribe:', error.message);
-}

package/test-hooks-manual.js

@@ -1,54 +0,0 @@
-/**
- * Manual test script for hooks functionality
- * Run with: node test-hooks-manual.js
- */
-
-import { setup, subscribe, emit } from '@stonyx/events';
-
-console.log('Testing hooks system...\n');
-
-// Setup events
-const eventNames = ['before:create:animal', 'after:create:animal'];
-setup(eventNames);
-
-let beforeCalled = false;
-let afterCalled = false;
-let contextReceived = null;
-
-// Subscribe to hooks
-const unsubscribe1 = subscribe('before:create:animal', async (context) => {
-  console.log('✓ before:create:animal hook called');
-  console.log('  Context:', JSON.stringify(context, null, 2));
-  beforeCalled = true;
-  contextReceived = context;
-});
-
-const unsubscribe2 = subscribe('after:create:animal', async (context) => {
-  console.log('✓ after:create:animal hook called');
-  console.log('  Context:', JSON.stringify(context, null, 2));
-  afterCalled = true;
-});
-
-// Simulate hook execution
-const testContext = {
-  model: 'animal',
-  operation: 'create',
-  body: { data: { type: 'animals', attributes: { name: 'Test' } } }
-};
-
-console.log('Emitting before:create:animal...');
-await emit('before:create:animal', testContext);
-
-console.log('\nEmitting after:create:animal...');
-await emit('after:create:animal', { ...testContext, record: { id: 1, name: 'Test' } });
-
-console.log('\n--- Test Results ---');
-console.log('Before hook called:', beforeCalled ? '✓ PASS' : '✗ FAIL');
-console.log('After hook called:', afterCalled ? '✓ PASS' : '✗ FAIL');
-console.log('Context passed correctly:', contextReceived?.model === 'animal' ? '✓ PASS' : '✗ FAIL');
-
-// Cleanup
-unsubscribe1();
-unsubscribe2();
-
-console.log('\n✓ Hooks system working correctly!');

package/test-hooks-with-logging.js

@@ -1,52 +0,0 @@
-/**
- * Test to verify hooks wrapper is being called
- */
-
-import { emit } from '@stonyx/events';
-
-// Simulate the _withHooks wrapper
-function _withHooks(operation, handler, model) {
-  console.log(`Creating wrapper for ${operation} on ${model}`);
-
-  return async (request, state) => {
-    console.log(`Wrapper called for ${operation} on ${model}`);
-
-    const context = {
-      model,
-      operation,
-      request,
-    };
-
-    console.log(`About to emit before:${operation}:${model}`);
-    await emit(`before:${operation}:${model}`, context);
-    console.log(`Emitted before hook`);
-
-    const response = await handler(request, state);
-    console.log(`Handler completed`);
-
-    context.response = response;
-    await emit(`after:${operation}:${model}`, context);
-    console.log(`Emitted after hook`);
-
-    return response;
-  };
-}
-
-// Simulate a handler
-const createHandler = ({ body }) => {
-  console.log('Original handler called');
-  return { data: { id: 1, ...body } };
-};
-
-// Create wrapped handler
-const wrappedHandler = _withHooks('create', createHandler, 'animal');
-
-// Simulate a request
-const mockRequest = {
-  body: { name: 'Test' }
-};
-
-console.log('\n=== Testing wrapper ===');
-const result = await wrappedHandler(mockRequest, {});
-console.log('Result:', result);
-console.log('\n✓ Wrapper test completed');