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

package/src/hooks.js

@@ -1,124 +0,0 @@
-/*
- * 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.
- */
-
-/**
- * Middleware-based hooks registry for ORM operations.
- * Unlike event-based hooks, middleware hooks run sequentially and can halt operations.
- */
-
-// Map of "operation:model" -> handler[]
-const beforeHooks = new Map();
-const afterHooks = new Map();
-
-/**
- * Register a before hook middleware that runs before the operation executes.
- *
- * @param {string} operation - Operation name: 'create', 'update', 'delete', 'get', or 'list'
- * @param {string} model - Model name (e.g., 'user', 'animal')
- * @param {Function} handler - Middleware function (context) => any
- *   - Return undefined to continue to next hook/handler
- *   - Return any value to halt operation (integer = HTTP status, object = response body)
- * @returns {Function} Unsubscribe function
- */
-export function beforeHook(operation, model, handler) {
-  const key = `${operation}:${model}`;
-  if (!beforeHooks.has(key)) {
-    beforeHooks.set(key, []);
-  }
-  beforeHooks.get(key).push(handler);
-
-  // Return unsubscribe function
-  return () => {
-    const hooks = beforeHooks.get(key);
-    if (hooks) {
-      const index = hooks.indexOf(handler);
-      if (index > -1) hooks.splice(index, 1);
-    }
-  };
-}
-
-/**
- * Register an after hook middleware that runs after the operation completes.
- * After hooks cannot halt operations (they run after completion).
- *
- * @param {string} operation - Operation name
- * @param {string} model - Model name
- * @param {Function} handler - Middleware function (context) => void
- * @returns {Function} Unsubscribe function
- */
-export function afterHook(operation, model, handler) {
-  const key = `${operation}:${model}`;
-  if (!afterHooks.has(key)) {
-    afterHooks.set(key, []);
-  }
-  afterHooks.get(key).push(handler);
-
-  // Return unsubscribe function
-  return () => {
-    const hooks = afterHooks.get(key);
-    if (hooks) {
-      const index = hooks.indexOf(handler);
-      if (index > -1) hooks.splice(index, 1);
-    }
-  };
-}
-
-/**
- * Get all before hooks for an operation:model combination.
- * @param {string} operation
- * @param {string} model
- * @returns {Function[]}
- */
-export function getBeforeHooks(operation, model) {
-  const key = `${operation}:${model}`;
-  return beforeHooks.get(key) || [];
-}
-
-/**
- * Get all after hooks for an operation:model combination.
- * @param {string} operation
- * @param {string} model
- * @returns {Function[]}
- */
-export function getAfterHooks(operation, model) {
-  const key = `${operation}:${model}`;
-  return afterHooks.get(key) || [];
-}
-
-/**
- * Clear registered hooks for a specific operation:model.
- *
- * @param {string} operation - Operation name
- * @param {string} model - Model name
- * @param {string} [type] - 'before' or 'after' (if omitted, clears both)
- */
-export function clearHook(operation, model, type) {
-  const key = `${operation}:${model}`;
-  if (!type || type === 'before') {
-    beforeHooks.set(key, []);
-  }
-  if (!type || type === 'after') {
-    afterHooks.set(key, []);
-  }
-}
-
-/**
- * Clear all hooks (useful for testing).
- */
-export function clearAllHooks() {
-  beforeHooks.clear();
-  afterHooks.clear();
-}

package/src/main.js

@@ -1,148 +0,0 @@
-/*
- * 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 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';
-import { setup } from '@stonyx/events';
-
-const defaultOptions = {
-  dbType: 'json'
-}
-
-export default class Orm {
-  static initialized = false;
-  static relationships = new Map();
-  static store = new Store();
-  
-  models = {};
-  serializers = {};
-  transforms = { ...baseTransforms };
-  warnings = new Set();
-
-  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, 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, recursive: true, recursiveNaming: true });
-    });
-
-    // Wait for imports before db & rest server setup
-    await Promise.all(promises);
-
-    // Setup event names for hooks after models are loaded
-    const eventNames = [];
-    const operations = ['list', 'get', 'create', 'update', 'delete'];
-    const timings = ['before', 'after'];
-
-    for (const modelName of Orm.store.data.keys()) {
-      for (const timing of timings) {
-        for (const operation of operations) {
-          eventNames.push(`${timing}:${operation}:${modelName}`);
-        }
-      }
-    }
-
-    setup(eventNames);
-
-    if (config.orm.mysql) {
-      const { default: MysqlDB } = await import('./mysql/mysql-db.js');
-      this.mysqlDb = new MysqlDB();
-      this.db = this.mysqlDb;
-      promises.push(this.mysqlDb.init());
-    } else 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;
-  }
-
-  async startup() {
-    if (this.mysqlDb) await this.mysqlDb.startup();
-  }
-
-  async shutdown() {
-    if (this.mysqlDb) await this.mysqlDb.shutdown();
-  }
-
-  static get db() {
-    if (!Orm.initialized) throw new Error('ORM has not been initialized yet');
-
-    return Orm.instance.db;
-  }
-
-  getRecordClasses(modelName) {
-    const modelClassPrefix = kebabCaseToPascalCase(modelName);
-  
-    return {
-      modelClass: this.models[`${modelClassPrefix}Model`],
-      serializerClass: this.serializers[`${modelClassPrefix}Serializer`] || Serializer
-    };
-  }
-
-  // Queue warnings to avoid the same error from being logged in the same iteration
-  warn(message) {
-    this.warnings.add(message);
-
-    setTimeout(() => {
-      this.warnings.forEach(warning => log.warn(warning));
-      this.warnings.clear();
-    }, 0);
-  }
-}
-
-export const store = Orm.store;
-export const relationships = Orm.relationships;

package/src/manage-record.js

@@ -1,118 +0,0 @@
-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.
- *
- * In MySQL mode with numeric IDs, assigns a temporary pending ID.
- * MySQL's AUTO_INCREMENT provides the real ID after INSERT.
- */
-function assignRecordId(modelName, rawData) {
-  if (rawData.id) return;
-
-  // In MySQL mode with numeric IDs, defer to MySQL auto-increment
-  if (Orm.instance?.mysqlDb && !isStringIdModel(modelName)) {
-    rawData.id = `__pending_${Date.now()}_${Math.random()}`;
-    rawData.__pendingMysqlId = true;
-    return;
-  }
-
-  const modelStore = Array.from(store.get(modelName).values());
-  rawData.id = modelStore.length ? modelStore.at(-1).id + 1 : 1;
-}
-
-function isStringIdModel(modelName) {
-  const { modelClass } = Orm.instance.getRecordClasses(modelName);
-  if (!modelClass) return false;
-
-  const model = new modelClass(modelName);
-
-  return model.id?.type === 'string';
-}

package/src/model-property.js

@@ -1,29 +0,0 @@
-import Orm from '@stonyx/orm';
-
-function validType(type) {
-  return Object.keys(Orm.instance.transforms).includes(type);
-}
-
-export default class ModelProperty {
-  constructor(type='passthrough', defaultValue) {
-    if (!validType(type)) throw new Error(`Invalid model property type: ${type}`);
-    
-    this.type = type;
-    this.value = defaultValue;
-  }
-
-  get value() {
-    return this._value;
-  }
-
-  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,9 +0,0 @@
-import { attr } from '@stonyx/orm';
-
-export default class Model {
-  id = attr('number');
-
-  constructor(name) {
-    this.__name = name;
-  }
-}

package/src/mysql/migration-generator.js

@@ -1,188 +0,0 @@
-import { introspectModels, buildTableDDL, schemasToSnapshot, getTopologicalOrder } from './schema-introspector.js';
-import { readFile, createFile, createDirectory, fileExists } from '@stonyx/utils/file';
-import path from 'path';
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-
-export async function generateMigration(description = 'migration') {
-  const { migrationsDir } = config.orm.mysql;
-  const rootPath = config.rootPath;
-  const migrationsPath = path.resolve(rootPath, migrationsDir);
-
-  await createDirectory(migrationsPath);
-
-  const schemas = introspectModels();
-  const currentSnapshot = schemasToSnapshot(schemas);
-  const previousSnapshot = await loadLatestSnapshot(migrationsPath);
-  const diff = diffSnapshots(previousSnapshot, currentSnapshot);
-
-  if (!diff.hasChanges) {
-    log.db('No schema changes detected.');
-    return null;
-  }
-
-  const upStatements = [];
-  const downStatements = [];
-
-  // New tables — in topological order (parents before children)
-  const allOrder = getTopologicalOrder(schemas);
-  const addedOrdered = allOrder.filter(name => diff.addedModels.includes(name));
-
-  for (const name of addedOrdered) {
-    upStatements.push(buildTableDDL(name, schemas[name], schemas) + ';');
-    downStatements.unshift(`DROP TABLE IF EXISTS \`${schemas[name].table}\`;`);
-  }
-
-  // Removed tables (warn only, commented out)
-  for (const name of diff.removedModels) {
-    upStatements.push(`-- WARNING: Model '${name}' was removed. Uncomment to drop table:`);
-    upStatements.push(`-- DROP TABLE IF EXISTS \`${previousSnapshot[name].table}\`;`);
-    downStatements.push(`-- Recreate table for removed model '${name}' manually if needed`);
-  }
-
-  // Added columns
-  for (const { model, column, type } of diff.addedColumns) {
-    const table = currentSnapshot[model].table;
-    upStatements.push(`ALTER TABLE \`${table}\` ADD COLUMN \`${column}\` ${type};`);
-    downStatements.push(`ALTER TABLE \`${table}\` DROP COLUMN \`${column}\`;`);
-  }
-
-  // Removed columns
-  for (const { model, column, type } of diff.removedColumns) {
-    const table = previousSnapshot[model].table;
-    upStatements.push(`ALTER TABLE \`${table}\` DROP COLUMN \`${column}\`;`);
-    downStatements.push(`ALTER TABLE \`${table}\` ADD COLUMN \`${column}\` ${type};`);
-  }
-
-  // Changed column types
-  for (const { model, column, from, to } of diff.changedColumns) {
-    const table = currentSnapshot[model].table;
-    upStatements.push(`ALTER TABLE \`${table}\` MODIFY COLUMN \`${column}\` ${to};`);
-    downStatements.push(`ALTER TABLE \`${table}\` MODIFY COLUMN \`${column}\` ${from};`);
-  }
-
-  // Added foreign keys
-  for (const { model, column, references } of diff.addedForeignKeys) {
-    const table = currentSnapshot[model].table;
-    // Resolve FK column type from the referenced table's PK type
-    const refModel = Object.entries(currentSnapshot).find(([, s]) => s.table === references.references);
-    const fkType = refModel && refModel[1].idType === 'string' ? 'VARCHAR(255)' : 'INT';
-    upStatements.push(`ALTER TABLE \`${table}\` ADD COLUMN \`${column}\` ${fkType};`);
-    upStatements.push(`ALTER TABLE \`${table}\` ADD FOREIGN KEY (\`${column}\`) REFERENCES \`${references.references}\`(\`${references.column}\`) ON DELETE SET NULL;`);
-    downStatements.push(`ALTER TABLE \`${table}\` DROP FOREIGN KEY \`${column}\`;`);
-    downStatements.push(`ALTER TABLE \`${table}\` DROP COLUMN \`${column}\`;`);
-  }
-
-  // Removed foreign keys
-  for (const { model, column, references } of diff.removedForeignKeys) {
-    const table = previousSnapshot[model].table;
-    // Resolve FK column type from the referenced table's PK type in previous snapshot
-    const refModel = Object.entries(previousSnapshot).find(([, s]) => s.table === references.references);
-    const fkType = refModel && refModel[1].idType === 'string' ? 'VARCHAR(255)' : 'INT';
-    upStatements.push(`ALTER TABLE \`${table}\` DROP FOREIGN KEY \`${column}\`;`);
-    upStatements.push(`ALTER TABLE \`${table}\` DROP COLUMN \`${column}\`;`);
-    downStatements.push(`ALTER TABLE \`${table}\` ADD COLUMN \`${column}\` ${fkType};`);
-    downStatements.push(`ALTER TABLE \`${table}\` ADD FOREIGN KEY (\`${column}\`) REFERENCES \`${references.references}\`(\`${references.column}\`) ON DELETE SET NULL;`);
-  }
-
-  const sanitizedDescription = description.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
-  const timestamp = Math.floor(Date.now() / 1000);
-  const filename = `${timestamp}_${sanitizedDescription}.sql`;
-  const content = `-- UP\n${upStatements.join('\n')}\n\n-- DOWN\n${downStatements.join('\n')}\n`;
-
-  await createFile(path.join(migrationsPath, filename), content);
-  await createFile(path.join(migrationsPath, '.snapshot.json'), JSON.stringify(currentSnapshot, null, 2));
-
-  log.db(`Migration generated: ${filename}`);
-
-  return { filename, content, snapshot: currentSnapshot };
-}
-
-export async function loadLatestSnapshot(migrationsPath) {
-  const snapshotPath = path.join(migrationsPath, '.snapshot.json');
-  const exists = await fileExists(snapshotPath);
-
-  if (!exists) return {};
-
-  return readFile(snapshotPath, { json: true });
-}
-
-export function diffSnapshots(previous, current) {
-  const addedModels = [];
-  const removedModels = [];
-  const addedColumns = [];
-  const removedColumns = [];
-  const changedColumns = [];
-  const addedForeignKeys = [];
-  const removedForeignKeys = [];
-
-  // Find added models
-  for (const name of Object.keys(current)) {
-    if (!previous[name]) addedModels.push(name);
-  }
-
-  // Find removed models
-  for (const name of Object.keys(previous)) {
-    if (!current[name]) removedModels.push(name);
-  }
-
-  // Find column changes in existing models
-  for (const name of Object.keys(current)) {
-    if (!previous[name]) continue;
-
-    const { columns: prevCols = {} } = previous[name];
-    const { columns: currCols = {} } = current[name];
-
-    // Added columns
-    for (const [col, type] of Object.entries(currCols)) {
-      if (!prevCols[col]) {
-        addedColumns.push({ model: name, column: col, type });
-      } else if (prevCols[col] !== type) {
-        changedColumns.push({ model: name, column: col, from: prevCols[col], to: type });
-      }
-    }
-
-    // Removed columns
-    for (const [col, type] of Object.entries(prevCols)) {
-      if (!currCols[col]) {
-        removedColumns.push({ model: name, column: col, type });
-      }
-    }
-
-    // Foreign key changes
-    const prevFKs = previous[name].foreignKeys || {};
-    const currFKs = current[name].foreignKeys || {};
-
-    for (const [col, refs] of Object.entries(currFKs)) {
-      if (!prevFKs[col]) {
-        addedForeignKeys.push({ model: name, column: col, references: refs });
-      }
-    }
-
-    for (const [col, refs] of Object.entries(prevFKs)) {
-      if (!currFKs[col]) {
-        removedForeignKeys.push({ model: name, column: col, references: refs });
-      }
-    }
-  }
-
-  const hasChanges = addedModels.length > 0 || removedModels.length > 0 ||
-    addedColumns.length > 0 || removedColumns.length > 0 ||
-    changedColumns.length > 0 || addedForeignKeys.length > 0 || removedForeignKeys.length > 0;
-
-  return {
-    hasChanges,
-    addedModels,
-    removedModels,
-    addedColumns,
-    removedColumns,
-    changedColumns,
-    addedForeignKeys,
-    removedForeignKeys,
-  };
-}
-
-export function detectSchemaDrift(schemas, snapshot) {
-  const current = schemasToSnapshot(schemas);
-  return diffSnapshots(snapshot, current);
-}