@stonyx/orm 0.2.1-alpha.4 → 0.2.1-alpha.40

package/src/mysql/mysql-db.js

@@ -1,422 +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.loadMemoryRecords();
-  }
-
-  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.loadMemoryRecords();
-      } 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.loadMemoryRecords();
-          }
-        } 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()
-  }
-
-  /**
-   * Loads only models with memory: true into the in-memory store on startup.
-   * Models with memory: false are skipped — accessed on-demand via find()/findAll().
-   */
-  async loadMemoryRecords() {
-    const schemas = this.deps.introspectModels();
-    const order = this.deps.getTopologicalOrder(schemas);
-    const Orm = (await import('@stonyx/orm')).default;
-
-    for (const modelName of order) {
-      // Check the model's memory flag — skip non-memory models
-      const { modelClass } = Orm.instance.getRecordClasses(modelName);
-      if (modelClass?.memory === false) {
-        this.deps.log.db(`Skipping memory load for '${modelName}' (memory: false)`);
-        continue;
-      }
-
-      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;
-      }
-    }
-  }
-
-  /**
-   * @deprecated Use loadMemoryRecords() instead. Kept for backward compatibility.
-   */
-  async loadAllRecords() {
-    return this.loadMemoryRecords();
-  }
-
-  /**
-   * Find a single record by ID from MySQL.
-   * Does NOT cache the result in the store for memory: false models.
-   * @param {string} modelName
-   * @param {string|number} id
-   * @returns {Promise<Record|undefined>}
-   */
-  async findRecord(modelName, id) {
-    const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
-
-    if (!schema) return undefined;
-
-    const { sql, values } = this.deps.buildSelect(schema.table, { id });
-
-    try {
-      const [rows] = await this.pool.execute(sql, values);
-
-      if (rows.length === 0) return undefined;
-
-      const rawData = this._rowToRawData(rows[0], schema);
-      const record = this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false });
-
-      // Don't let memory:false records accumulate in the store
-      // The caller keeps the reference; the store doesn't retain it
-      this._evictIfNotMemory(modelName, record);
-
-      return record;
-    } catch (error) {
-      if (error.code === 'ER_NO_SUCH_TABLE') return undefined;
-      throw error;
-    }
-  }
-
-  /**
-   * Find all records of a model from MySQL, with optional conditions.
-   * @param {string} modelName
-   * @param {Object} [conditions] - Optional WHERE conditions (key-value pairs)
-   * @returns {Promise<Record[]>}
-   */
-  async findAll(modelName, conditions) {
-    const schemas = this.deps.introspectModels();
-    const schema = schemas[modelName];
-
-    if (!schema) return [];
-
-    const { sql, values } = this.deps.buildSelect(schema.table, conditions);
-
-    try {
-      const [rows] = await this.pool.execute(sql, values);
-
-      const records = rows.map(row => {
-        const rawData = this._rowToRawData(row, schema);
-        return this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false });
-      });
-
-      // Don't let memory:false records accumulate in the store
-      for (const record of records) {
-        this._evictIfNotMemory(modelName, record);
-      }
-
-      return records;
-    } catch (error) {
-      if (error.code === 'ER_NO_SUCH_TABLE') return [];
-      throw error;
-    }
-  }
-
-  /**
-   * Remove a record from the in-memory store if its model has memory: false.
-   * The record object itself survives — the caller retains the reference.
-   * This prevents on-demand queries from leaking records into the store.
-   * @private
-   */
-  _evictIfNotMemory(modelName, record) {
-    const store = this.deps.store;
-
-    // Use the memory resolver if available (set by Orm.init)
-    if (store._memoryResolver && !store._memoryResolver(modelName)) {
-      const modelStore = store.get?.(modelName) ?? store.data?.get(modelName);
-      if (modelStore) modelStore.delete(record.id);
-    }
-  }
-
-  _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;
-  }
-}

package/src/mysql/schema-introspector.js

@@ -1,159 +0,0 @@
-import Orm from '@stonyx/orm';
-import { getMysqlType } from './type-map.js';
-import { camelCaseToKebabCase } from '@stonyx/utils/string';
-import { pluralize } from '../utils.js';
-import { dbKey } from '../db.js';
-
-function getRelationshipInfo(property) {
-  if (typeof property !== 'function') return null;
-  const fnStr = property.toString();
-
-  if (fnStr.includes(`getRelationships('belongsTo',`)) return 'belongsTo';
-  if (fnStr.includes(`getRelationships('hasMany',`)) return 'hasMany';
-
-  return null;
-}
-
-export function introspectModels() {
-  const { models } = Orm.instance;
-  const schemas = {};
-
-  for (const [modelKey, modelClass] of Object.entries(models)) {
-    const name = camelCaseToKebabCase(modelKey.slice(0, -5));
-
-    if (name === dbKey) continue;
-
-    const model = new modelClass(modelKey);
-    const columns = {};
-    const foreignKeys = {};
-    const relationships = { belongsTo: {}, hasMany: {} };
-    let idType = 'number';
-
-    const transforms = Orm.instance.transforms;
-
-    for (const [key, property] of Object.entries(model)) {
-      if (key.startsWith('__')) continue;
-
-      const relType = getRelationshipInfo(property);
-
-      if (relType === 'belongsTo') {
-        relationships.belongsTo[key] = true;
-      } else if (relType === 'hasMany') {
-        relationships.hasMany[key] = true;
-      } else if (property?.constructor?.name === 'ModelProperty') {
-        if (key === 'id') {
-          idType = property.type;
-        } else {
-          columns[key] = getMysqlType(property.type, transforms[property.type]);
-        }
-      }
-    }
-
-    // Build foreign keys from belongsTo relationships
-    for (const relName of Object.keys(relationships.belongsTo)) {
-      const fkColumn = `${relName}_id`;
-      foreignKeys[fkColumn] = {
-        references: pluralize(relName),
-        column: 'id',
-      };
-    }
-
-    schemas[name] = {
-      table: pluralize(name),
-      idType,
-      columns,
-      foreignKeys,
-      relationships,
-      memory: modelClass.memory !== false, // default true for backward compat
-    };
-  }
-
-  return schemas;
-}
-
-export function buildTableDDL(name, schema, allSchemas = {}) {
-  const { table, idType, columns, foreignKeys } = schema;
-  const lines = [];
-
-  // Primary key
-  if (idType === 'string') {
-    lines.push('  `id` VARCHAR(255) PRIMARY KEY');
-  } else {
-    lines.push('  `id` INT AUTO_INCREMENT PRIMARY KEY');
-  }
-
-  // Attribute columns
-  for (const [col, mysqlType] of Object.entries(columns)) {
-    lines.push(`  \`${col}\` ${mysqlType}`);
-  }
-
-  // Foreign key columns
-  for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
-    const refIdType = getReferencedIdType(fkDef.references, allSchemas);
-    lines.push(`  \`${fkCol}\` ${refIdType}`);
-  }
-
-  // Timestamps
-  lines.push('  `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP');
-  lines.push('  `updated_at` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
-
-  // 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`);
-  }
-
-  return `CREATE TABLE IF NOT EXISTS \`${table}\` (\n${lines.join(',\n')}\n)`;
-}
-
-function getReferencedIdType(tableName, allSchemas) {
-  // Look up the referenced table's PK type from schemas
-  for (const schema of Object.values(allSchemas)) {
-    if (schema.table === tableName) {
-      return schema.idType === 'string' ? 'VARCHAR(255)' : 'INT';
-    }
-  }
-
-  // Default to INT if referenced table not found in schemas
-  return 'INT';
-}
-
-export function getTopologicalOrder(schemas) {
-  const visited = new Set();
-  const order = [];
-
-  function visit(name) {
-    if (visited.has(name)) return;
-    visited.add(name);
-
-    const schema = schemas[name];
-    if (!schema) return;
-
-    // Visit dependencies (belongsTo targets) first
-    for (const relName of Object.keys(schema.relationships.belongsTo)) {
-      visit(relName);
-    }
-
-    order.push(name);
-  }
-
-  for (const name of Object.keys(schemas)) {
-    visit(name);
-  }
-
-  return order;
-}
-
-export function schemasToSnapshot(schemas) {
-  const snapshot = {};
-
-  for (const [name, schema] of Object.entries(schemas)) {
-    snapshot[name] = {
-      table: schema.table,
-      idType: schema.idType,
-      columns: { ...schema.columns },
-      foreignKeys: { ...schema.foreignKeys },
-    };
-  }
-
-  return snapshot;
-}

package/src/record.js

@@ -1,127 +0,0 @@
-import { store } from './index.js';
-import { getComputedProperties } from "./serializer.js";
-import { camelCaseToKebabCase } from '@stonyx/utils/string';
-import { pluralize } from './utils.js';
-export default class Record {
-  __data = {};
-  __relationships = {};
-  __serialized = false;
-
-  constructor(model, serializer) {
-    this.__model = model;
-    this.__serializer = serializer;
-
-  }
-
-  serialize(rawData, options={}) {
-    const { __data:data } = this;
-    
-    if (this.__serialized && !options.update) {
-      const relatedIds = {};
-
-      for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-        relatedIds[key] = Array.isArray(childRecord) 
-        ? childRecord.map(r => r.id)
-        : childRecord?.id ?? null;
-      }
-
-      return { ...data, ...relatedIds };
-    }
-
-    const normalizedData = this.__serializer.normalize(rawData);
-    this.__serializer.setProperties(normalizedData, this, options);
-
-    return data;
-  }
-
-  // Similar to serialize, but preserves top level relationship records
-  format() {
-    if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
-    
-    const { __data:data } = this;
-    const records = {};
-
-    for (const [ key, childRecord ] of Object.entries(this.__relationships)) {
-      records[key] = Array.isArray(childRecord) 
-      ? childRecord.map(r => r.serialize())
-      : childRecord?.serialize() ?? null;
-    }
-
-    return { ...data, ...records };
-  }
-
-  // Formats record for JSON API output
-  toJSON(options = {}) {
-    if (!this.__serialized) throw new Error('Record must be serialized before being converted to JSON');
-
-    const { fields, baseUrl } = options;
-    const { __data:data } = this;
-    const modelName = this.__model.__name;
-    const pluralizedModelName = pluralize(modelName);
-    const recordId = data.id;
-    const relationships = {};
-    const attributes = {};
-
-    for (const [key, value] of Object.entries(data)) {
-      if (key === 'id') continue;
-      if (fields && !fields.has(key)) continue;
-      attributes[key] = value;
-    }
-
-    for (const [key, getter] of getComputedProperties(this.__model)) {
-      if (fields && !fields.has(key)) continue;
-      attributes[key] = getter.call(this);
-    }
-
-    for (const [key, childRecord] of Object.entries(this.__relationships)) {
-      if (fields && !fields.has(key)) continue;
-
-      const relationshipData = Array.isArray(childRecord)
-        ? childRecord.map(r => ({ type: r.__model.__name, id: r.id }))
-        : childRecord ? { type: childRecord.__model.__name, id: childRecord.id } : null;
-
-      // Dasherize the key for URL paths (e.g., accessLinks -> access-links)
-      const dasherizedKey = camelCaseToKebabCase(key);
-
-      relationships[dasherizedKey] = { data: relationshipData };
-
-      // Add links to relationship if baseUrl provided
-      if (baseUrl) {
-        relationships[dasherizedKey].links = {
-          self: `${baseUrl}/${pluralizedModelName}/${recordId}/relationships/${dasherizedKey}`,
-          related: `${baseUrl}/${pluralizedModelName}/${recordId}/${dasherizedKey}`
-        };
-      }
-    }
-
-    const result = {
-      attributes,
-      relationships,
-      id: recordId,
-      type: modelName,
-    };
-
-    // Add resource links if baseUrl provided
-    if (baseUrl) {
-      result.links = {
-        self: `${baseUrl}/${pluralizedModelName}/${recordId}`
-      };
-    }
-
-    return result;
-  }
-
-  unload(options={}) {
-    store.unloadRecord(this.__model.__name, this.id, options);
-  }
-
-  clean() {
-    try {
-      for (const key of Object.keys(this)) {
-        delete this[key];
-      }
-    } catch {
-      // Ignore errors during cleanup, as some keys may not be deletable
-    }
-  }
-}