@stonyx/orm 0.1.0 → 0.2.1-alpha.0

package/src/db.js

@@ -1,18 +1,26 @@
-/**
- * TODO:
- * 
- * ORM DB usage assumes that 100% of the data is ORM driven
- * With that assumption, we can safely do the following
- * - On save: Remove computed properties (getters) from data set
- * - On load: Compute computed properties from data set
- *   - Error handling: Warn of non-ORM properties found in data (but load them)
- *   - Optional configuration flag to disable these warnings
+/*
+ * Copyright 2025 Stone Costa
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
+
 import Cron from '@stonyx/cron';
 import config from 'stonyx/config';
 import log from 'stonyx/log';
+import Orm, { createRecord, store } from '@stonyx/orm';
 import { createFile, updateFile, readFile } from '@stonyx/utils/file';
-import { deepCopy } from '@stonyx/utils/object';
+
+export const dbKey = '__db';
 
 export default class DB {
   constructor() {
@@ -21,10 +29,22 @@ export default class DB {
     DB.instance = this;
   }
 
-  async init() {
-    await this.retrieve();
+  async getSchema() {
+    const { rootPath } = config;
+    const { file, schema } = config.orm.db;
+
+    if (!file) throw new Error('Configuration Error: ORM DB file path must be defined.');
 
+    return (await import(`${rootPath}/${schema}`)).default;
+  }
+
+  async init() {
     const { autosave, saveInterval } = config.orm.db;
+    
+    store.set(dbKey, new Map());
+    Orm.instance.models[`${dbKey}Model`] = await this.getSchema();
+
+    this.record = await this.getRecord();
 
     if (autosave !== 'true') return;
 
@@ -33,74 +53,28 @@ export default class DB {
 
   async create() {
     const { rootPath } = config;
-    const { file, schema } = config.orm.db;
-
-    if (!file) throw new Error('Configuration Error: ORM DB file path must be defined.');
-
-    let dbSchema;
-
-    try {
-      dbSchema = (await import(`${rootPath}/${schema}`)).default;
-    } catch (error) {
-      dbSchema = {};
-      log.db('Unable to load DB schema from file, using empty schema instead');
-    }
+    const { file } = config.orm.db;
 
-    const data = deepCopy(dbSchema);
-    
-    createFile(`${rootPath}/${file}`, data, { json: true });
+    createFile(`${rootPath}/${file}`, {}, { json: true });
 
-    return data;
+    return {};
   }
   
   async save() {
     const { file } = config.orm.db;
+    const jsonData = this.record.format();
+    delete jsonData.id; // Don't save id
 
-    await updateFile(`${config.rootPath}/${file}`, this.data, { json: true });
+    await updateFile(`${config.rootPath}/${file}`, jsonData, { json: true });
 
     log.db(`DB has been successfully saved to ${file}`);
   }
 
-  async retrieve() {
+  async getRecord() {
     const { file } = config.orm.db;
 
-    this.data = await readFile(file, { json: true, missingFileCallback: this.create.bind(this) });
-  }
-
-  /** TODO: We need ORM specific reload logic that replaces models attributes when loading from DB */
-  // _tempORMSerializeMeta(data) {
-  //   const { meta } = data;
-
-  //   // HACK: Create map to ensure we have no duplicate references
-  //   // This will no longer be necessary once once gatherer method prevents duplicates
-  //   const referenceIds = {};
-  //   const { shipmentReportReferences } = meta;
+    const data = await readFile(file, { json: true, missingFileCallback: this.create.bind(this) });
 
-  //   // Fix reference dates & remove duplicates
-  //   for (let i = shipmentReportReferences.length - 1; i >= 0; i--) {
-  //     const record = shipmentReportReferences[i];
-
-  //     if (!referenceIds[record.id]) {
-  //       referenceIds[record.id] = record;
-  //     } else {
-  //       shipmentReportReferences.splice(i, 1);
-  //     }
-
-  //     if (!record.date) continue;
-
-  //     record.date = new Date(record.date);
-  //   }
-
-  //   // Re-compute
-  //   const metaModel = new MODELS.MetaModel();
-
-  //   // Serialize computed properties
-  //   for (const [key, method] of getComputedProperties(metaModel)) {
-  //      const value = method.bind(meta)();
-      
-  //      meta[key] = value;
-  //   }
-
-  //   return data;
-  // }
+    return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false });
+  }
 }

package/src/exports/db.js

@@ -0,0 +1,7 @@
+import Orm from '@stonyx/orm';
+
+const { db } = Orm;
+
+export default db;
+export const data = db.record;
+export const saveDB = db.save.bind(db);

package/src/has-many.js

@@ -0,0 +1,61 @@
+import { createRecord, relationships, store } from '@stonyx/orm';
+import { getRelationships } from './relationships.js';
+import { getOrSet, makeArray } from '@stonyx/utils/object';
+import { dbKey } from './db.js';
+
+function queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, id) {
+  pendingRelationshipQueue.push({
+    pendingRelationship: getOrSet(pendingRelationships, modelName, new Map()),
+    id
+  });
+
+  return null;
+}
+
+export default function hasMany(modelName) {
+  const globalRelationships = relationships.get('global');
+  const pendingRelationships = relationships.get('pending');
+
+  return (sourceRecord, rawData, options) => {
+    const { __name: sourceModelName } = sourceRecord.__model;
+    const relationshipId = sourceRecord.id;
+    const relationship = getRelationships('hasMany', sourceModelName, modelName, relationshipId);
+    const modelStore = store.get(modelName);
+    const pendingRelationshipQueue = [];
+
+    const output = !rawData ? [] : makeArray(rawData).map(elementData => {
+      let record;
+
+      if (typeof elementData !== 'object') {
+        record = modelStore.get(elementData);
+
+        if (!record) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+      } else {
+        if (elementData !== Object(elementData)) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+
+        record = createRecord(modelName, elementData, options);
+      }
+
+      // Populate belongTo side if the relationship is defined
+      const otherSide = relationships.get('belongsTo').get(modelName)?.get(sourceModelName)?.get(record.id);
+
+      if (otherSide) Object.assign(otherSide, sourceRecord);
+
+      return record;
+    }).filter(value => value);
+
+    relationship.set(relationshipId, output);
+        
+    // Assign global relationship
+    if (options.global || sourceModelName === dbKey) getOrSet(globalRelationships, modelName, []).push(output);
+
+    // Assign pending relationships
+    for (const { pendingRelationship, id } of pendingRelationshipQueue) getOrSet(pendingRelationship, id, []).push(output);
+
+    return output;
+  }
+}

package/src/index.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2025 Stone Costa
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Model from './model.js';
+import Serializer from './serializer.js';
+
+import attr from './attr.js';
+import belongsTo from './belongs-to.js';
+import hasMany from './has-many.js';
+import { createRecord, updateRecord } from './manage-record.js';
+
+export { default } from './main.js';
+export { store, relationships } from './main.js';
+export { Model, Serializer }; // base classes
+export { attr, belongsTo, hasMany, createRecord, updateRecord }; // helpers

package/src/main.js

@@ -14,50 +14,85 @@
  * limitations under the License.
  */
 
-import DB from "@stonyx/orm/db";
-import config from "stonyx/config";
-import BaseModel from "./model.js";
-import BaseSerializer from "./serializer.js";
-import ModelProperty from "./model-property.js";
-import Record from "./record.js";
-import { makeArray } from "@stonyx/utils/object";
-import { forEachFileImport } from "@stonyx/utils/file";
-import { kebabCaseToPascalCase, pluralize } from "@stonyx/utils/string";
-import baseTransforms from "./transforms.js";
+import DB from './db.js';
+import config from 'stonyx/config';
+import log from 'stonyx/log';
+import { forEachFileImport } from '@stonyx/utils/file';
+import { kebabCaseToPascalCase, pluralize } from '@stonyx/utils/string';
+import setupRestServer from './setup-rest-server.js';
+import baseTransforms from './transforms.js';
+import Store from './store.js';
+import Serializer from './serializer.js';
+
+const defaultOptions = {
+  dbType: 'json'
+}
 
 export default class Orm {
-  initialized = false;
+  static initialized = false;
+  static relationships = new Map();
+  static store = new Store();
   
   models = {};
   serializers = {};
   transforms = { ...baseTransforms };
+  warnings = new Set();
 
-  constructor() {
+  constructor(options={}) {
     if (Orm.instance) return Orm.instance;
 
+    const { relationships } = Orm;
+
+    // Declare relationship maps
+    for (const key of ['hasMany', 'belongsTo', 'global', 'pending', 'pendingBelongsTo']) {
+      relationships.set(key, new Map());
+    }
+
+    this.options = { ...defaultOptions, ...options };
+
     Orm.instance = this;
   }
 
   async init() {
-    const { paths } = config.orm;
+    const { paths, restServer } = config.orm;
     const promises = ['Model', 'Serializer', 'Transform'].map(type => {
       const lowerCaseType = type.toLowerCase();
       const path = paths[lowerCaseType];
+
       if (!path) throw new Error(`Configuration Error: ORM path for "${type}" must be defined.`);
 
       return forEachFileImport(path, (exported, { name }) => {
         // Transforms keep their original name, everything else gets converted to PascalCase with the type suffix
         const alias = type === 'Transform' ? name : `${kebabCaseToPascalCase(name)}${type}`;
 
+        if (type === 'Model') Orm.store.set(name, new Map());
+
         return this[pluralize(lowerCaseType)][alias] = exported;
-      }, { ignoreAccessFailure: true, rawName: true });
+      }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
     });
 
-    promises.push(new DB().init());
-
+    // Wait for imports before db & rest server setup
     await Promise.all(promises);
-    
-    this.initialized = true;
+
+    if (this.options.dbType !== 'none') {
+      const db = new DB();
+      this.db = db;
+      
+      promises.push(db.init());
+    }
+
+    if (restServer.enabled === 'true') {
+      promises.push(setupRestServer(restServer.route, paths.access, restServer.metaRoute));
+    }
+
+    Orm.ready = await Promise.all(promises);
+    Orm.initialized = true;
+  }
+
+  static get db() {
+    if (!Orm.initialized) throw new Error('ORM has not been initialized yet');
+
+    return Orm.instance.db;
   }
 
   getRecordClasses(modelName) {
@@ -65,36 +100,20 @@ export default class Orm {
   
     return {
       modelClass: this.models[`${modelClassPrefix}Model`],
-      serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || BaseSerializer
+      serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
     };
   }
-}
-
-export { BaseModel, BaseSerializer };
 
-export function attr() {
-  return new ModelProperty(...arguments);
-}
-
-export function belongsTo(modelName) {
-  return rawData => createRecord(modelName, rawData);
-}
+  // Queue warnings to avoid the same error from being logged in the same iteration
+  warn(message) {
+    this.warnings.add(message);
 
-export function hasMany(modelName) {
-  return rawData => makeArray(rawData).map(elementData => createRecord(modelName, elementData));
+    setTimeout(() => {
+      this.warnings.forEach(warning => log.warn(warning));
+      this.warnings.clear();
+    }, 0);
+  }
 }
 
-export function createRecord(modelName, rawData={}) {
-  if (!Orm.instance.initialized) throw new Error("ORM is not ready");
-
-  const { modelClass, serializerClass } = Orm.instance.getRecordClasses(modelName);
-
-  if (!modelClass) throw new Error(`A model named "${modelName}" does not exist`);
-
-  const model = new modelClass(modelName);
-  const serializer = new serializerClass(model);
-  const record = new Record(model, serializer);
-
-  record.serialize(rawData);
-  return record;
-}
+export const store = Orm.store;
+export const relationships = Orm.relationships;

package/src/manage-record.js

@@ -0,0 +1,103 @@
+import Orm, { store, relationships } from '@stonyx/orm';
+import Record from './record.js';
+
+const defaultOptions = {
+  isDbRecord: false,
+  serialize: true,
+  transform: true
+};
+
+export function createRecord(modelName, rawData={}, userOptions={}) {
+  const orm = Orm.instance;
+  const { initialized } = Orm;
+  const options = { ...defaultOptions, ...userOptions };
+
+  if (!initialized && !options.isDbRecord) throw new Error('ORM is not ready');
+
+  const modelStore = store.get(modelName);
+  const globalRelationships = relationships.get('global');
+  const pendingRelationships = relationships.get('pending');
+
+  assignRecordId(modelName, rawData);
+  if (modelStore.has(rawData.id)) return modelStore.get(rawData.id);
+
+  const { modelClass, serializerClass } = orm.getRecordClasses(modelName);
+
+  if (!modelClass) throw new Error(`A model named '${modelName}' does not exist`);
+
+  const model = new modelClass(modelName);
+  const serializer = new serializerClass(model);
+  const record = new Record(model, serializer);
+
+  record.serialize(rawData, options);
+  modelStore.set(record.id, record);
+
+  // populate global hasMany relationships
+  const globalHasMany = globalRelationships.get(modelName);
+  if (globalHasMany) for (const relationship of globalHasMany) relationship.push(record);
+
+  // populate pending hasMany relationships and clear the queue
+  const pendingHasMany = pendingRelationships.get(modelName)?.get(record.id);
+  if (pendingHasMany) {
+    for (const relationship of pendingHasMany) relationship.push(record);
+    pendingHasMany.splice(0);
+  }
+
+  // Fulfill pending belongsTo relationships
+  const pendingBelongsToQueue = relationships.get('pendingBelongsTo');
+  const pendingBelongsTo = pendingBelongsToQueue.get(modelName)?.get(record.id);
+
+  if (pendingBelongsTo) {
+    const belongsToReg = relationships.get('belongsTo');
+    const hasManyReg = relationships.get('hasMany');
+
+    for (const { sourceRecord, sourceModelName, relationshipKey, relationshipId } of pendingBelongsTo) {
+      // Update the belongsTo relationship on the source record
+      sourceRecord.__relationships[relationshipKey] = record;
+      sourceRecord[relationshipKey] = record; // Also update the direct property
+
+      // Update the belongsTo relationship registry
+      const sourceModelReg = belongsToReg.get(sourceModelName);
+      if (sourceModelReg) {
+        const targetModelReg = sourceModelReg.get(modelName);
+        if (targetModelReg) {
+          targetModelReg.set(relationshipId, record);
+        }
+      }
+
+      // Wire inverse hasMany if it exists
+      const inverseHasMany = hasManyReg.get(modelName)?.get(sourceModelName)?.get(record.id);
+
+      if (inverseHasMany && !inverseHasMany.includes(sourceRecord)) {
+        inverseHasMany.push(sourceRecord);
+      }
+    }
+
+    // Clear the pending queue
+    pendingBelongsTo.length = 0;
+  }
+
+  return record;
+}
+
+export function updateRecord(record, rawData, userOptions={}) {
+  if (!rawData) throw new Error('rawData must be passed in to updateRecord call');
+
+  const options = { ...defaultOptions, ...userOptions, update:true };
+
+  record.serialize(rawData, options);
+}
+
+/**
+ * gets the next available id based on last record entry.
+ * 
+ * Note/TODO: Records going into a db should get their id from the db instead
+ * Atm, i think the best way to do that would be as an id override that happens after the
+ * record is created
+ */
+function assignRecordId(modelName, rawData) {
+  if (rawData.id) return;
+
+  const modelStore = Array.from(store.get(modelName).values());
+  rawData.id = modelStore.length ? modelStore.at(-1).id + 1 : 1;
+}

package/src/meta-request.js

@@ -0,0 +1,55 @@
+import { Request } from '@stonyx/rest-server';
+import Orm from '@stonyx/orm';
+import config from 'stonyx/config';
+import { dbKey } from './db.js';
+
+export default class MetaRequest extends Request {
+  constructor() {
+    super(...arguments);
+    
+    this.handlers = {
+      get: {
+        '/meta': () => {
+          try {
+            const { models } = Orm.instance;
+            const metadata = {};
+
+            for (const [modelName, modelClass] of Object.entries(models)) {
+              const name = modelName.slice(0, -5).toLowerCase();
+
+              if (name === dbKey) continue;
+
+              const model = new modelClass(modelName);
+              const properties = {};
+
+              // Get regular properties and relationships
+              for (const [key, property] of Object.entries(model)) {
+                // Skip internal properties
+                if (key.startsWith('__')) continue;
+
+                if (property?.constructor?.name === 'ModelProperty') {
+                  properties[key] = { type: property.type };
+                } else if (typeof property === 'function') {
+                  const isBelongsTo = property.toString().includes(`getRelationships('belongsTo',`);
+                  const isHasMany = property.toString().includes(`getRelationships('hasMany',`);
+
+                  if (isBelongsTo || isHasMany) properties[key] = { [isBelongsTo ? 'belongsTo' : 'hasMany']: name };
+                }
+              }
+
+              metadata[name] = properties;
+            }
+
+            return metadata;            
+          } catch (error) {
+            return { error: error.message };
+          }
+        },
+      },
+    }
+  }
+
+  auth() {
+    if (!config.orm.restServer.metaRoute) return 403;
+  }
+}

package/src/model-property.js

@@ -17,6 +17,13 @@ export default class ModelProperty {
   }
 
   set value(newValue) {
+    if (this.ignoreFirstTransform) {
+      delete this.ignoreFirstTransform;
+      return this._value = newValue;
+    }
+
+    if (newValue === undefined || newValue === null) return;
+
     this._value = Orm.instance.transforms[this.type](newValue);
   }
 }

package/src/model.js

@@ -1,4 +1,8 @@
-export default class BaseModel {
+import { attr } from '@stonyx/orm';
+
+export default class Model {
+  id = attr('number');
+
   constructor(name) {
     this.__name = name;
   }