@stonyx/orm 0.2.1-beta.9 → 0.2.1-beta.91

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,211 +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();
-  }
-
-  get(key, id) {
-    if (!id) return this.data.get(key);
-
-    return this.data.get(key)?.get(id);
-  }
-
-  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');