@stonyx/orm 0.2.1-alpha.14 → 0.2.1-alpha.15

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.1-alpha.14",
+  "version": "0.2.1-alpha.15",
   "description": "",
   "main": "src/main.js",
   "type": "module",
@@ -38,11 +38,15 @@
     "@stonyx/cron": "0.2.1-beta.12"
   },
   "peerDependencies": {
-    "mysql2": "^3.0.0"
+    "mysql2": "^3.0.0",
+    "@stonyx/rest-server": ">=0.2.1-beta.14"
   },
   "peerDependenciesMeta": {
     "mysql2": {
       "optional": true
+    },
+    "@stonyx/rest-server": {
+      "optional": true
     }
   },
   "devDependencies": {

package/src/belongs-to.js

@@ -11,7 +11,7 @@ export default function belongsTo(modelName) {
   const pendingHasManyQueue = relationships.get('pending');
   const pendingBelongsToQueue = relationships.get('pendingBelongsTo');
 
-  return (sourceRecord, rawData, options) => {
+  const fn = (sourceRecord, rawData, options) => {
     if (!rawData) return null;
 
     const { __name: sourceModelName } = sourceRecord.__model;
@@ -60,4 +60,7 @@ export default function belongsTo(modelName) {
 
     return output;
   }
+
+  fn.__relatedModelName = modelName;
+  return fn;
 }

package/src/has-many.js

@@ -16,7 +16,7 @@ export default function hasMany(modelName) {
   const globalRelationships = relationships.get('global');
   const pendingRelationships = relationships.get('pending');
 
-  return (sourceRecord, rawData, options) => {
+  const fn = (sourceRecord, rawData, options) => {
     const { __name: sourceModelName } = sourceRecord.__model;
     const relationshipId = sourceRecord.id;
     const relationship = getRelationships('hasMany', sourceModelName, modelName, relationshipId);
@@ -58,4 +58,7 @@ export default function hasMany(modelName) {
 
     return output;
   }
+
+  fn.__relatedModelName = modelName;
+  return fn;
 }

package/src/main.js

@@ -113,7 +113,7 @@ export default class Orm {
     // Wire up memory resolver so store.find() can check model memory flags
     Orm.store._memoryResolver = (modelName) => {
       const { modelClass } = this.getRecordClasses(modelName);
-      return modelClass?.memory === true;
+      return modelClass?.memory !== false;
     };
 
     // Wire up MySQL reference for on-demand queries from store.find()/findAll()

package/src/model.js

@@ -4,12 +4,12 @@ export default class Model {
   /**
    * Controls whether records of this model are loaded into memory on startup.
    *
-   * - true  → loaded on boot, kept in store
-   * - false → never cached; find() always queries MySQL (default)
+   * - true  → loaded on boot, kept in store (default for backward compatibility)
+   * - false → never cached; find() always queries MySQL
    *
-   * Override in subclass: static memory = true;
+   * Override in subclass: static memory = false;
    */
-  static memory = false;
+  static memory = true;
   static pluralName = undefined;
 
   id = attr('number');

package/src/mysql/schema-introspector.js

@@ -7,13 +7,18 @@ import { dbKey } from '../db.js';
 function getRelationshipInfo(property) {
   if (typeof property !== 'function') return null;
   const fnStr = property.toString();
+  const modelName = property.__relatedModelName || null;
 
-  if (fnStr.includes(`getRelationships('belongsTo',`)) return 'belongsTo';
-  if (fnStr.includes(`getRelationships('hasMany',`)) return 'hasMany';
+  if (fnStr.includes(`getRelationships('belongsTo',`)) return { type: 'belongsTo', modelName };
+  if (fnStr.includes(`getRelationships('hasMany',`)) return { type: 'hasMany', modelName };
 
   return null;
 }
 
+function sanitizeTableName(name) {
+  return name.replace(/\//g, '_');
+}
+
 export function introspectModels() {
   const { models } = Orm.instance;
   const schemas = {};
@@ -34,12 +39,12 @@ export function introspectModels() {
     for (const [key, property] of Object.entries(model)) {
       if (key.startsWith('__')) continue;
 
-      const relType = getRelationshipInfo(property);
+      const relInfo = getRelationshipInfo(property);
 
-      if (relType === 'belongsTo') {
-        relationships.belongsTo[key] = true;
-      } else if (relType === 'hasMany') {
-        relationships.hasMany[key] = true;
+      if (relInfo?.type === 'belongsTo') {
+        relationships.belongsTo[key] = relInfo.modelName;
+      } else if (relInfo?.type === 'hasMany') {
+        relationships.hasMany[key] = relInfo.modelName;
       } else if (property?.constructor?.name === 'ModelProperty') {
         if (key === 'id') {
           idType = property.type;
@@ -50,22 +55,21 @@ export function introspectModels() {
     }
 
     // Build foreign keys from belongsTo relationships
-    for (const relName of Object.keys(relationships.belongsTo)) {
-      const modelName = camelCaseToKebabCase(relName);
+    for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
       const fkColumn = `${relName}_id`;
       foreignKeys[fkColumn] = {
-        references: getPluralName(modelName),
+        references: sanitizeTableName(getPluralName(targetModelName)),
         column: 'id',
       };
     }
 
     schemas[name] = {
-      table: getPluralName(name),
+      table: sanitizeTableName(getPluralName(name)),
       idType,
       columns,
       foreignKeys,
       relationships,
-      memory: modelClass.memory === true,
+      memory: modelClass.memory !== false, // default true for backward compat
     };
   }
 
@@ -73,7 +77,8 @@ export function introspectModels() {
 }
 
 export function buildTableDDL(name, schema, allSchemas = {}) {
-  const { table, idType, columns, foreignKeys } = schema;
+  const { idType, columns, foreignKeys } = schema;
+  const table = sanitizeTableName(schema.table);
   const lines = [];
 
   // Primary key
@@ -100,7 +105,8 @@ export function buildTableDDL(name, schema, allSchemas = {}) {
 
   // 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`);
+    const refTable = sanitizeTableName(fkDef.references);
+    lines.push(`  FOREIGN KEY (\`${fkCol}\`) REFERENCES \`${refTable}\`(\`${fkDef.column}\`) ON DELETE SET NULL`);
   }
 
   return `CREATE TABLE IF NOT EXISTS \`${table}\` (\n${lines.join(',\n')}\n)`;
@@ -130,8 +136,8 @@ export function getTopologicalOrder(schemas) {
     if (!schema) return;
 
     // Visit dependencies (belongsTo targets) first
-    for (const relName of Object.keys(schema.relationships.belongsTo)) {
-      visit(camelCaseToKebabCase(relName));
+    for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
+      visit(targetModelName);
     }
 
     order.push(name);

package/src/store.js

@@ -117,7 +117,7 @@ export default class Store {
    */
   _isMemoryModel(modelName) {
     if (this._memoryResolver) return this._memoryResolver(modelName);
-    return false; // default to non-memory if resolver not set yet
+    return true; // default to memory if resolver not set yet
   }
 
   set(key, value) {