@stonyx/orm 0.2.1-alpha.0 → 0.2.1-alpha.10

package/src/store.js

@@ -9,12 +9,117 @@ export default class Store {
     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);
   }

package/src/utils.js

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,41 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,52 @@
+/**
+ * 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');