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

package/src/mysql/schema-introspector.js

@@ -1,158 +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,
-    };
-  }
-
-  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
-    }
-  }
-}

package/src/relationships.js

@@ -1,43 +0,0 @@
-import { relationships } from "@stonyx/orm";
-
-export default class Relationships {
-  constructor() {
-    if (Relationships.instance) return Relationships.instance;
-    Relationships.instance = this;
-
-    this.data = new Map();
-  }
-
-  get(key) {
-    return this.data.get(key);
-  }
-
-  set(key, value) {
-    this.data.set(key, value);
-  }
-}
-
-// TODO: Refactor mapping to remove a level of iteration
-export function getRelationships(type, sourceModel, targetModel, relationshipId) {
-  const allRelationships = relationships.get(type);
-  
-  // create relationship map for this type of it doesn't already exist
-  if (!allRelationships.has(sourceModel)) allRelationships.set(sourceModel, new Map());
-  
-  const modelRelationship = allRelationships.get(sourceModel);
-
-  if (!modelRelationship.has(targetModel)) modelRelationship.set(targetModel, new Map());
-
-  const relationship = modelRelationship.get(targetModel);
-
-  // TODO: Determine whether already having id should be handled differently
-  //if (relationship.has(relationshipId)) return;
-
-  return relationship;
-}
-
-export function getHasManyRelationships(sourceModel, targetModel) {
-  return relationships.get('hasMany').get(sourceModel)?.get(targetModel);
-}
-
-export const TYPES = ['global', 'hasMany', 'belongsTo', 'pending'];

package/src/serializer.js

@@ -1,138 +0,0 @@
-import config from 'stonyx/config';
-import { get, makeArray } from '@stonyx/utils/object';
-
-const RESERVED_KEYS = ['__name'];
-
-function searchQuery(query, array, key) {
-  const result = makeArray(array).find(item => {
-    for (const [ prop, value ] of Object.entries(query)) {
-      if (item[prop] !== value) return false;
-
-      return true;
-    }
-  });
-
-  if (!result) return null;
-  if (key) return result[key];
-
-  return result;
-}
-
-function query(rawData, pathPrefix, subPath) {
-  if (!rawData) return null;
-
-  const [ path, getter, pointer ] = makeArray(subPath);
-  const fullPath = `${pathPrefix}${path}`;
-  const value = get(rawData, fullPath);
-
-  if (getter === undefined || getter === null) return value;
-
-  try {
-    switch(typeof getter) {
-      case 'object':
-        return searchQuery(getter, value, pointer);
-
-      case 'function':
-        return getter(value);
-
-      case 'number':
-        const element = value[getter];
-        return pointer ? element[pointer] : element;
-
-      default: 
-        return value[getter];
-    }
-  } catch (error) {
-    if (config.debug) console.error(`Cannot parse value for ${fullPath}.`, { getter, query }, error);
-  }
-}
-
-export default class Serializer {
-  map = {};
-  path = '';
-
-  constructor(model) {
-    this.model = model;
-  }
-
-  /**
-   * This method populates the record's instance with instances of
-   * the ModelProperty object, while setting parsed values to the record's
-   * __data property, which represents the serialized version of the data
-   */
-  setProperties(rawData, record, options) {
-    const { path, model } = this;
-    const keys = Object.keys(model).filter(key => !RESERVED_KEYS.includes(key));
-    const pathPrefix = path ? `${path}.` : '';
-    const { __data:parsedData, __relationships:relatedRecords } = record;
-
-    for (const key of keys) {
-      const subPath = options.serialize ? (this.map[key] || key) : key;
-      const handler = model[key];
-      const data = query(rawData, pathPrefix, subPath);
-
-      // Ignore null/undefined values on updates (TODO: What if we want it set to null?)
-      if ((data === null || data === undefined) && options.update) continue;
-
-      // Relationship handling
-      if (typeof handler === 'function') {
-        // Pass relationship key name to handler for pending fulfillment
-        const handlerOptions = { ...options, _relationshipKey: key };
-        const childRecord = handler(record, data, handlerOptions);
-
-        record[key] = childRecord
-        relatedRecords[key] = childRecord;
-
-        continue;
-      }
-
-      // Direct assignment handling
-      if (handler?.constructor?.name !== 'ModelProperty') {
-        parsedData[key] = handler;
-        record[key] = handler;
-        continue;
-      }
-
-      Object.defineProperty(record, key, {
-        enumerable: true,
-        configurable: true,
-        get: () => handler.value,
-        set(newValue) {
-          handler.ignoreFirstTransform = !options.transform;
-          handler.value = newValue;
-          parsedData[key] = handler.value;
-        }
-      });
-
-      record[key] = data;
-    }
-
-    if (options.update) return;
-
-    // Serialize computed properties
-    for (const [key, getter] of getComputedProperties(this.model)) {
-      Object.defineProperty(record, key, {
-        enumerable: true,
-        get: () => getter.call(record)
-      });
-    }
-
-    record.__serialized = true;
-  }
-
-  /**
-   * OVERRIDE: This hook allows for data manipulation prior to serialization logic
-   */
-  normalize(data) {
-    return data;
-  }
-}
-
-export function getComputedProperties(classInstance) {
-  const proto = Object.getPrototypeOf(classInstance);
-  if (!proto || proto === Object.prototype) return [];
-  
-  return Object.entries(Object.getOwnPropertyDescriptors(proto))
-    .filter(([key, descriptor]) => key !== 'constructor' && descriptor.get)
-    .map(([key, descriptor]) => [key, descriptor.get]);
-}

package/src/store.js

@@ -1,211 +0,0 @@
-import { relationships } from '@stonyx/orm';
-import { TYPES } from './relationships.js';
-
-export default class Store {
-  constructor() {
-    if (Store.instance) return Store.instance;
-    Store.instance = this;
-
-    this.data = new Map();
-  }
-
-  get(key, id) {
-    if (!id) return this.data.get(key);
-
-    return this.data.get(key)?.get(id);
-  }
-
-  set(key, value) {
-    this.data.set(key, value);
-  }
-
-  remove(key, id) {
-    if (id) return this.unloadRecord(key, id);
-
-    this.unloadAllRecords(key);
-  }
-
-  unloadRecord(model, id, options={}) {
-    const modelStore = this.data.get(model);
-
-    if (!modelStore) {
-      console.warn(`[Store] Cannot unload record: model "${model}" not found in store`);
-      return;
-    }
-
-    const record = modelStore.get(id);
-
-    if (!record) {
-      console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store`);
-      return;
-    }
-
-    const { toUnload, visited } = options.includeChildren
-      ? this._buildUnloadQueue(record, options)
-      : { toUnload: [{ record, modelName: model, recordId: id }], visited: new Set([`${model}:${id}`]) };
-
-    for (const item of toUnload.reverse()) {
-      const { record: recordToUnload, modelName, recordId } = item;
-
-      this._removeFromHasManyArrays(modelName, recordId, visited);
-      this._nullifyBelongsToReferences(modelName, recordId, visited);
-      this._cleanupRelationshipRegistries(modelName, recordId);
-      recordToUnload.clean();
-
-      this.data.get(modelName).delete(recordId);
-    }
-  }
-
-  unloadAllRecords(model, options={}) {
-    const modelStore = this.data.get(model);
-
-    if (!modelStore) {
-      console.warn(`[Store] Cannot unload all records: model "${model}" not found in store`);
-      return;
-    }
-
-    const recordIds = Array.from(modelStore.keys());
-
-    for (const id of recordIds) {
-      if (modelStore.has(id)) {
-        this.unloadRecord(model, id, options);
-      }
-    }
-
-    for (const relationshipType of TYPES) relationships.get(relationshipType).delete(model);
-  }
-
-  _removeFromHasManyArrays(modelName, recordId, visited) {
-    const hasManyRegistry = relationships.get('hasMany');
-
-    for (const [sourceModel, targetModels] of hasManyRegistry) {
-      const targetModelMap = targetModels.get(modelName);
-      if (!targetModelMap) continue;
-
-      for (const [sourceRecordId, hasManyArray] of targetModelMap) {
-        const sourceKey = `${sourceModel}:${sourceRecordId}`;
-
-        // Don't modify arrays of records being deleted
-        if (visited.has(sourceKey)) continue;
-
-        const index = hasManyArray.findIndex(r => r && r.id === recordId);
-        if (index !== -1) hasManyArray.splice(index, 1);
-      }
-    }
-  }
-
-  _nullifyBelongsToReferences(modelName, recordId, visited) {
-    const belongsToRegistry = relationships.get('belongsTo');
-
-    for (const [sourceModel, targetModels] of belongsToRegistry) {
-      const targetModelMap = targetModels.get(modelName);
-      if (!targetModelMap) continue;
-
-      for (const [sourceRecordId, belongsToRecord] of targetModelMap) {
-        if (belongsToRecord && belongsToRecord.id === recordId) {
-          const sourceKey = `${sourceModel}:${sourceRecordId}`;
-
-          if (visited.has(sourceKey)) continue;
-          targetModelMap.set(sourceRecordId, null);
-
-          const sourceRecord = this.get(sourceModel, sourceRecordId);
-          if (sourceRecord && sourceRecord.__relationships) {
-            for (const [key, value] of Object.entries(sourceRecord.__relationships)) {
-              if (value && value.id === recordId) {
-                sourceRecord.__relationships[key] = null;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  _cleanupRelationshipRegistries(modelName, recordId) {
-    const hasManyMap = relationships.get('hasMany').get(modelName);
-    if (hasManyMap) {
-      for (const [, recordMap] of hasManyMap) recordMap.delete(recordId);
-    }
-
-    const belongsToMap = relationships.get('belongsTo').get(modelName);
-    if (belongsToMap) {
-      for (const [, recordMap] of belongsToMap) recordMap.delete(recordId);
-    }
-
-    const pendingMap = relationships.get('pending').get(modelName);
-    if (pendingMap) pendingMap.delete(recordId);
-  }
-
-  /**
-   * Extracts hasMany and non-bidirectional belongsTo children from a record
-   * @private
-   */
-  _getChildren(record) {
-    const children = [];
-
-    if (!record.__relationships) return children;
-
-    for (const [key, value] of Object.entries(record.__relationships)) {
-      // hasMany children - always include
-      if (Array.isArray(value)) {
-        for (const childRecord of value) {
-          if (childRecord) children.push({ childRecord, relationshipKey: key, type: 'hasMany' });
-        }
-      } else if (value && !this._isBidirectionalRelationship(
-        record.__model.__name,
-        value.__model.__name
-      )) {
-        children.push({ childRecord: value, relationshipKey: key, type: 'belongsTo' });
-      }
-    }
-
-    return children;
-  }
-
-  _isBidirectionalRelationship(sourceModel, targetModel) {
-    const hasManyRegistry = relationships.get('hasMany');
-    const inverseMap = hasManyRegistry.get(targetModel)?.get(sourceModel);
-
-    return inverseMap && inverseMap.size > 0;
-  }
-
-  _buildUnloadQueue(record, options) {
-    const visited = new Set();
-    const toUnload = [];
-    const queue = [{
-      record,
-      modelName: record.__model.__name,
-      recordId: record.id,
-      isRoot: true,
-      depth: 0
-    }];
-
-    while (queue.length > 0) {
-      const item = queue.shift();
-      const key = `${item.modelName}:${item.recordId}`;
-
-      if (visited.has(key)) continue;
-      visited.add(key);
-
-      toUnload.push(item);
-
-      // Add children to queue if includeChildren is enabled
-      if (options.includeChildren) {
-        const children = this._getChildren(item.record);
-        for (const { childRecord } of children) {
-          if (childRecord) {
-            queue.push({
-              record: childRecord,
-              modelName: childRecord.__model.__name,
-              recordId: childRecord.id,
-              isRoot: false,
-              depth: item.depth + 1
-            });
-          }
-        }
-      }
-    }
-
-    return { toUnload, visited };
-  }
-}

package/src/transforms.js

@@ -1,20 +0,0 @@
-import { getTimestamp } from "@stonyx/utils/date";
-
-const transforms = {
-  boolean: value => typeof value === 'string' ? value.trim().toLowerCase() === 'true' : !!value,
-  date: value => value ? new Date(value) : null,
-  float: value => parseFloat(value),
-  number: value => parseInt(value),
-  passthrough: value => value,
-  string: value => String(value),
-  timestamp: value => getTimestamp(value),
-  trim: value => value?.trim(),
-  uppercase: value => value?.toUpperCase(),
-};
-
-// Math Proxies
-['ceil', 'floor', 'round'].forEach(method => {
-  transforms[method] = value => Math[method](value);
-});
-
-export default transforms;

package/src/utils.js

@@ -1,12 +0,0 @@
-import { pluralize as basePluralize } from '@stonyx/utils/string';
-
-// Wrapper to handle dasherized model names (e.g., "access-link" → "access-links")
-export function pluralize(word) {
-  if (word.includes('-')) {
-    const parts = word.split('-');
-    const pluralizedLast = basePluralize(parts.pop());
-    return [...parts, pluralizedLast].join('-');
-  }
-
-  return basePluralize(word);
-}