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

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);
-}

package/src/mysql/mysql-db.js

@@ -1,320 +0,0 @@
-import { getPool, closePool } from './connection.js';
-import { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } from './migration-runner.js';
-import { introspectModels, getTopologicalOrder, schemasToSnapshot } from './schema-introspector.js';
-import { loadLatestSnapshot, detectSchemaDrift } from './migration-generator.js';
-import { buildInsert, buildUpdate, buildDelete, buildSelect } from './query-builder.js';
-import { createRecord, store } from '@stonyx/orm';
-import { confirm } from '@stonyx/utils/prompt';
-import { readFile } from '@stonyx/utils/file';
-import { pluralize } from '../utils.js';
-import config from 'stonyx/config';
-import log from 'stonyx/log';
-import path from 'path';
-
-const defaultDeps = {
-  getPool, closePool, ensureMigrationsTable, getAppliedMigrations,
-  getMigrationFiles, applyMigration, parseMigrationFile,
-  introspectModels, getTopologicalOrder, schemasToSnapshot,
-  loadLatestSnapshot, detectSchemaDrift,
-  buildInsert, buildUpdate, buildDelete, buildSelect,
-  createRecord, store, confirm, readFile, pluralize, config, log, path
-};
-
-export default class MysqlDB {
-  constructor(deps = {}) {
-    if (MysqlDB.instance) return MysqlDB.instance;
-    MysqlDB.instance = this;
-
-    this.deps = { ...defaultDeps, ...deps };
-    this.pool = null;
-    this.mysqlConfig = this.deps.config.orm.mysql;
-  }
-
-  async init() {
-    this.pool = await this.deps.getPool(this.mysqlConfig);
-    await this.deps.ensureMigrationsTable(this.pool, this.mysqlConfig.migrationsTable);
-    await this.loadAllRecords();
-  }
-
-  async startup() {
-    const migrationsPath = this.deps.path.resolve(this.deps.config.rootPath, this.mysqlConfig.migrationsDir);
-
-    // Check for pending migrations
-    const applied = await this.deps.getAppliedMigrations(this.pool, this.mysqlConfig.migrationsTable);
-    const files = await this.deps.getMigrationFiles(migrationsPath);
-    const pending = files.filter(f => !applied.includes(f));
-
-    if (pending.length > 0) {
-      this.deps.log.db(`${pending.length} pending migration(s) found.`);
-
-      const shouldApply = await this.deps.confirm(`${pending.length} pending migration(s) found. Apply now?`);
-
-      if (shouldApply) {
-        for (const filename of pending) {
-          const content = await this.deps.readFile(this.deps.path.join(migrationsPath, filename));
-          const { up } = this.deps.parseMigrationFile(content);
-
-          await this.deps.applyMigration(this.pool, filename, up, this.mysqlConfig.migrationsTable);
-          this.deps.log.db(`Applied migration: ${filename}`);
-        }
-
-        // Reload records after applying migrations
-        await this.loadAllRecords();
-      } else {
-        this.deps.log.warn('Skipping pending migrations. Schema may be outdated.');
-      }
-    } else if (files.length === 0) {
-      const schemas = this.deps.introspectModels();
-      const modelCount = Object.keys(schemas).length;
-
-      if (modelCount > 0) {
-        const shouldGenerate = await this.deps.confirm(
-          `No migrations found but ${modelCount} model(s) detected. Generate and apply initial migration?`
-        );
-
-        if (shouldGenerate) {
-          const { generateMigration } = await import('./migration-generator.js');
-          const result = await generateMigration('initial_setup');
-
-          if (result) {
-            const { up } = this.deps.parseMigrationFile(result.content);
-            await this.deps.applyMigration(this.pool, result.filename, up, this.mysqlConfig.migrationsTable);
-            this.deps.log.db(`Applied migration: ${result.filename}`);
-            await this.loadAllRecords();
-          }
-        } else {
-          this.deps.log.warn('Skipping initial migration. Tables may not exist.');
-        }
-      }
-    }
-
-    // Check for schema drift
-    const schemas = this.deps.introspectModels();
-    const snapshot = await this.deps.loadLatestSnapshot(this.deps.path.resolve(this.deps.config.rootPath, this.mysqlConfig.migrationsDir));
-
-    if (Object.keys(snapshot).length > 0) {
-      const drift = this.deps.detectSchemaDrift(schemas, snapshot);
-
-      if (drift.hasChanges) {
-        this.deps.log.warn('Schema drift detected: models have changed since the last migration.');
-        this.deps.log.warn('Run `stonyx db:generate-migration` to create a new migration.');
-      }
-    }
-  }
-
-  async shutdown() {
-    await this.deps.closePool();
-    this.pool = null;
-  }
-
-  async save() {
-    // No-op: MySQL persists data immediately via persist()
-  }
-
-  async loadAllRecords() {
-    const schemas = this.deps.introspectModels();
-    const order = this.deps.getTopologicalOrder(schemas);
-
-    for (const modelName of order) {
-      const schema = schemas[modelName];
-      const { sql, values } = this.deps.buildSelect(schema.table);
-
-      try {
-        const [rows] = await this.pool.execute(sql, values);
-
-        for (const row of rows) {
-          const rawData = this._rowToRawData(row, schema);
-          this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false });
-        }
-      } catch (error) {
-        // Table may not exist yet (pre-migration) — skip gracefully
-        if (error.code === 'ER_NO_SUCH_TABLE') {
-          this.deps.log.db(`Table '${schema.table}' does not exist yet. Skipping load for '${modelName}'.`);
-          continue;
-        }
-
-        throw error;
-      }
-    }
-
-  }
-
-  _rowToRawData(row, schema) {
-    const rawData = { ...row };
-
-    for (const [col, mysqlType] of Object.entries(schema.columns)) {
-      if (rawData[col] == null) continue;
-
-      // Convert boolean columns from MySQL TINYINT(1) 0/1 to false/true
-      if (mysqlType === 'TINYINT(1)') {
-        rawData[col] = !!rawData[col];
-      }
-
-      // Parse JSON columns back to JS values (custom transforms stored as JSON)
-      if (mysqlType === 'JSON' && typeof rawData[col] === 'string') {
-        try { rawData[col] = JSON.parse(rawData[col]); } catch { /* keep raw string */ }
-      }
-    }
-
-    // Map FK columns back to relationship keys
-    // e.g., owner_id → owner (the belongsTo handler expects the id value under the relationship key name)
-    for (const [fkCol, fkDef] of Object.entries(schema.foreignKeys)) {
-      const relName = fkCol.replace(/_id$/, '');
-
-      if (rawData[fkCol] !== undefined) {
-        rawData[relName] = rawData[fkCol];
-        delete rawData[fkCol];
-      }
-    }
-
-    // Remove timestamp columns — managed by MySQL
-    delete rawData.created_at;
-    delete rawData.updated_at;
-
-    return rawData;
-  }
-
-  async persist(operation, modelName, context, response) {
-    switch (operation) {
-      case 'create':
-        return this._persistCreate(modelName, context, response);
-      case 'update':
-        return this._persistUpdate(modelName, context, response);
-      case 'delete':
-        return this._persistDelete(modelName, context);
-    }
-  }
-
-  async _persistCreate(modelName, context, response) {
-    const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
-
-    if (!schema) return;
-
-    const recordId = response?.data?.id;
-    const record = recordId != null ? this.deps.store.get(modelName, isNaN(recordId) ? recordId : parseInt(recordId)) : null;
-
-    if (!record) return;
-
-    const insertData = this._recordToRow(record, schema);
-
-    // For auto-increment models, remove the pending ID
-    const isPendingId = record.__data.__pendingMysqlId;
-
-    if (isPendingId) {
-      delete insertData.id;
-    } else if (insertData.id !== undefined) {
-      // Keep user-provided ID (string IDs or explicit numeric IDs)
-    }
-
-    const { sql, values } = this.deps.buildInsert(schema.table, insertData);
-
-    const [result] = await this.pool.execute(sql, values);
-
-    // Re-key the record in the store if MySQL generated the ID
-    if (isPendingId && result.insertId) {
-      const pendingId = record.id;
-      const realId = result.insertId;
-      const modelStore = this.deps.store.get(modelName);
-
-      modelStore.delete(pendingId);
-      record.__data.id = realId;
-      record.id = realId;
-      modelStore.set(realId, record);
-
-      // Update the response data with the real ID
-      if (response?.data) {
-        response.data.id = realId;
-      }
-
-      delete record.__data.__pendingMysqlId;
-    }
-  }
-
-  async _persistUpdate(modelName, context, response) {
-    const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
-
-    if (!schema) return;
-
-    const record = context.record;
-    if (!record) return;
-
-    const id = record.id;
-    const oldState = context.oldState || {};
-    const currentData = record.__data;
-
-    // Build a diff of changed columns
-    const changedData = {};
-
-    for (const [col] of Object.entries(schema.columns)) {
-      if (currentData[col] !== oldState[col]) {
-        changedData[col] = currentData[col] ?? null;
-      }
-    }
-
-    // Check FK changes too
-    for (const fkCol of Object.keys(schema.foreignKeys)) {
-      const relName = fkCol.replace(/_id$/, '');
-      const currentFkValue = record.__relationships[relName]?.id ?? null;
-      const oldFkValue = oldState[relName] ?? null;
-
-      if (currentFkValue !== oldFkValue) {
-        changedData[fkCol] = currentFkValue;
-      }
-    }
-
-    if (Object.keys(changedData).length === 0) return;
-
-    const { sql, values } = this.deps.buildUpdate(schema.table, id, changedData);
-    await this.pool.execute(sql, values);
-  }
-
-  async _persistDelete(modelName, context) {
-    const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
-
-    if (!schema) return;
-
-    const id = context.recordId;
-    if (id == null) return;
-
-    const { sql, values } = this.deps.buildDelete(schema.table, id);
-    await this.pool.execute(sql, values);
-  }
-
-  _recordToRow(record, schema) {
-    const row = {};
-    const data = record.__data;
-
-    // ID
-    if (data.id !== undefined) {
-      row.id = data.id;
-    }
-
-    // Attribute columns
-    for (const [col, mysqlType] of Object.entries(schema.columns)) {
-      if (data[col] !== undefined) {
-        // JSON columns: stringify non-string values for MySQL JSON storage
-        row[col] = mysqlType === 'JSON' && typeof data[col] !== 'string'
-          ? JSON.stringify(data[col])
-          : data[col];
-      }
-    }
-
-    // FK columns from relationships
-    for (const fkCol of Object.keys(schema.foreignKeys)) {
-      const relName = fkCol.replace(/_id$/, '');
-      const related = record.__relationships[relName];
-
-      if (related) {
-        row[fkCol] = related.id;
-      } else if (data[relName] !== undefined) {
-        // Raw FK value (e.g., from create payload)
-        row[fkCol] = data[relName];
-      }
-    }
-
-    return row;
-  }
-}