@stonyx/orm 0.2.1-beta.83 → 0.2.1-beta.85

package/src/{commands.js → commands.ts}

@@ -1,170 +1,179 @@
-import { fileToDirectory, directoryToFile } from './migrate.js';
-
-export default {
-  'db:migrate-to-directory': {
-    description: 'Migrate DB from single file to directory mode',
-    bootstrap: true,
-    run: async () => {
-      await fileToDirectory();
-      console.log('DB migration to directory mode complete.');
-    }
-  },
-  'db:migrate-to-file': {
-    description: 'Migrate DB from directory mode to single file',
-    bootstrap: true,
-    run: async () => {
-      await directoryToFile();
-      console.log('DB migration to file mode complete.');
-    }
-  },
-  'db:generate-migration': {
-    description: 'Generate a MySQL migration from current model schemas',
-    bootstrap: true,
-    run: async (args) => {
-      const description = args.join(' ') || 'migration';
-      const { generateMigration } = await import('./mysql/migration-generator.js');
-      const result = await generateMigration(description);
-
-      if (result) {
-        console.log(`Migration created: ${result.filename}`);
-      } else {
-        console.log('No schema changes detected. No migration generated.');
-      }
-    }
-  },
-  'db:migrate': {
-    description: 'Apply pending MySQL migrations',
-    bootstrap: true,
-    run: async () => {
-      const config = (await import('stonyx/config')).default;
-      const mysqlConfig = config.orm.mysql;
-
-      if (!mysqlConfig) {
-        console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
-        process.exit(1);
-      }
-
-      const { getPool, closePool } = await import('./mysql/connection.js');
-      const { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } = await import('./mysql/migration-runner.js');
-      const { readFile } = await import('@stonyx/utils/file');
-      const path = await import('path');
-
-      const pool = await getPool(mysqlConfig);
-      const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir);
-
-      try {
-        await ensureMigrationsTable(pool, mysqlConfig.migrationsTable);
-
-        const applied = await getAppliedMigrations(pool, mysqlConfig.migrationsTable);
-        const files = await getMigrationFiles(migrationsPath);
-        const pending = files.filter(f => !applied.includes(f));
-
-        if (pending.length === 0) {
-          console.log('No pending migrations.');
-          return;
-        }
-
-        console.log(`Applying ${pending.length} migration(s)...`);
-
-        for (const filename of pending) {
-          const content = await readFile(path.join(migrationsPath, filename));
-          const { up } = parseMigrationFile(content);
-
-          await applyMigration(pool, filename, up, mysqlConfig.migrationsTable);
-          console.log(`  Applied: ${filename}`);
-        }
-
-        console.log('All migrations applied.');
-      } finally {
-        await closePool();
-      }
-    }
-  },
-  'db:migrate:rollback': {
-    description: 'Rollback the most recent MySQL migration',
-    bootstrap: true,
-    run: async () => {
-      const config = (await import('stonyx/config')).default;
-      const mysqlConfig = config.orm.mysql;
-
-      if (!mysqlConfig) {
-        console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
-        process.exit(1);
-      }
-
-      const { getPool, closePool } = await import('./mysql/connection.js');
-      const { ensureMigrationsTable, getAppliedMigrations, rollbackMigration, parseMigrationFile } = await import('./mysql/migration-runner.js');
-      const { readFile } = await import('@stonyx/utils/file');
-      const path = await import('path');
-
-      const pool = await getPool(mysqlConfig);
-      const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir);
-
-      try {
-        await ensureMigrationsTable(pool, mysqlConfig.migrationsTable);
-
-        const applied = await getAppliedMigrations(pool, mysqlConfig.migrationsTable);
-
-        if (applied.length === 0) {
-          console.log('No migrations to rollback.');
-          return;
-        }
-
-        const lastFilename = applied[applied.length - 1];
-        const content = await readFile(path.join(migrationsPath, lastFilename));
-        const { down } = parseMigrationFile(content);
-
-        if (!down) {
-          console.error(`No DOWN section found in ${lastFilename}. Cannot rollback.`);
-          process.exit(1);
-        }
-
-        await rollbackMigration(pool, lastFilename, down, mysqlConfig.migrationsTable);
-        console.log(`Rolled back: ${lastFilename}`);
-      } finally {
-        await closePool();
-      }
-    }
-  },
-  'db:migrate:status': {
-    description: 'Show status of MySQL migrations',
-    bootstrap: true,
-    run: async () => {
-      const config = (await import('stonyx/config')).default;
-      const mysqlConfig = config.orm.mysql;
-
-      if (!mysqlConfig) {
-        console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
-        process.exit(1);
-      }
-
-      const { getPool, closePool } = await import('./mysql/connection.js');
-      const { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles } = await import('./mysql/migration-runner.js');
-      const path = await import('path');
-
-      const pool = await getPool(mysqlConfig);
-      const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir);
-
-      try {
-        await ensureMigrationsTable(pool, mysqlConfig.migrationsTable);
-
-        const applied = new Set(await getAppliedMigrations(pool, mysqlConfig.migrationsTable));
-        const files = await getMigrationFiles(migrationsPath);
-
-        if (files.length === 0) {
-          console.log('No migration files found.');
-          return;
-        }
-
-        console.log('Migration status:');
-
-        for (const filename of files) {
-          const status = applied.has(filename) ? 'applied' : 'pending';
-          console.log(`  [${status}] ${filename}`);
-        }
-      } finally {
-        await closePool();
-      }
-    }
-  },
-};
+import { fileToDirectory, directoryToFile } from './migrate.js';
+import type { MysqlConfig } from './mysql/connection.js';
+
+interface Command {
+  description: string;
+  bootstrap: boolean;
+  run: (args?: string[]) => Promise<void>;
+}
+
+const commands: Record<string, Command> = {
+  'db:migrate-to-directory': {
+    description: 'Migrate DB from single file to directory mode',
+    bootstrap: true,
+    run: async () => {
+      await fileToDirectory();
+      console.log('DB migration to directory mode complete.');
+    }
+  },
+  'db:migrate-to-file': {
+    description: 'Migrate DB from directory mode to single file',
+    bootstrap: true,
+    run: async () => {
+      await directoryToFile();
+      console.log('DB migration to file mode complete.');
+    }
+  },
+  'db:generate-migration': {
+    description: 'Generate a MySQL migration from current model schemas',
+    bootstrap: true,
+    run: async (args) => {
+      const description = args?.join(' ') || 'migration';
+      const { generateMigration } = await import('./mysql/migration-generator.js');
+      const result = await generateMigration(description);
+
+      if (result) {
+        console.log(`Migration created: ${result.filename}`);
+      } else {
+        console.log('No schema changes detected. No migration generated.');
+      }
+    }
+  },
+  'db:migrate': {
+    description: 'Apply pending MySQL migrations',
+    bootstrap: true,
+    run: async () => {
+      const config = (await import('stonyx/config')).default;
+      const mysqlConfig = config.orm.mysql;
+
+      if (!mysqlConfig) {
+        console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
+        process.exit(1);
+      }
+
+      const { getPool, closePool } = await import('./mysql/connection.js');
+      const { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } = await import('./mysql/migration-runner.js');
+      const { readFile } = await import('@stonyx/utils/file');
+      const path = await import('path');
+
+      const pool = await getPool(mysqlConfig as MysqlConfig);
+      const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir as string);
+
+      try {
+        await ensureMigrationsTable(pool, mysqlConfig.migrationsTable as string);
+
+        const applied = await getAppliedMigrations(pool, mysqlConfig.migrationsTable as string);
+        const files = await getMigrationFiles(migrationsPath);
+        const pending = files.filter((f: string) => !applied.includes(f));
+
+        if (pending.length === 0) {
+          console.log('No pending migrations.');
+          return;
+        }
+
+        console.log(`Applying ${pending.length} migration(s)...`);
+
+        for (const filename of pending) {
+          const content = await readFile(path.join(migrationsPath, filename) as string) as string;
+          const { up } = parseMigrationFile(content);
+
+          await applyMigration(pool, filename, up, mysqlConfig.migrationsTable as string);
+          console.log(`  Applied: ${filename}`);
+        }
+
+        console.log('All migrations applied.');
+      } finally {
+        await closePool();
+      }
+    }
+  },
+  'db:migrate:rollback': {
+    description: 'Rollback the most recent MySQL migration',
+    bootstrap: true,
+    run: async () => {
+      const config = (await import('stonyx/config')).default;
+      const mysqlConfig = config.orm.mysql;
+
+      if (!mysqlConfig) {
+        console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
+        process.exit(1);
+      }
+
+      const { getPool, closePool } = await import('./mysql/connection.js');
+      const { ensureMigrationsTable, getAppliedMigrations, rollbackMigration, parseMigrationFile } = await import('./mysql/migration-runner.js');
+      const { readFile } = await import('@stonyx/utils/file');
+      const path = await import('path');
+
+      const pool = await getPool(mysqlConfig as MysqlConfig);
+      const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir as string);
+
+      try {
+        await ensureMigrationsTable(pool, mysqlConfig.migrationsTable as string);
+
+        const applied = await getAppliedMigrations(pool, mysqlConfig.migrationsTable as string);
+
+        if (applied.length === 0) {
+          console.log('No migrations to rollback.');
+          return;
+        }
+
+        const lastFilename = applied[applied.length - 1];
+        const content = await readFile(path.join(migrationsPath, lastFilename) as string) as string;
+        const { down } = parseMigrationFile(content);
+
+        if (!down) {
+          console.error(`No DOWN section found in ${lastFilename}. Cannot rollback.`);
+          process.exit(1);
+        }
+
+        await rollbackMigration(pool, lastFilename, down, mysqlConfig.migrationsTable as string);
+        console.log(`Rolled back: ${lastFilename}`);
+      } finally {
+        await closePool();
+      }
+    }
+  },
+  'db:migrate:status': {
+    description: 'Show status of MySQL migrations',
+    bootstrap: true,
+    run: async () => {
+      const config = (await import('stonyx/config')).default;
+      const mysqlConfig = config.orm.mysql;
+
+      if (!mysqlConfig) {
+        console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
+        process.exit(1);
+      }
+
+      const { getPool, closePool } = await import('./mysql/connection.js');
+      const { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles } = await import('./mysql/migration-runner.js');
+      const path = await import('path');
+
+      const pool = await getPool(mysqlConfig as MysqlConfig);
+      const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir as string);
+
+      try {
+        await ensureMigrationsTable(pool, mysqlConfig.migrationsTable as string);
+
+        const applied = new Set(await getAppliedMigrations(pool, mysqlConfig.migrationsTable as string));
+        const files = await getMigrationFiles(migrationsPath);
+
+        if (files.length === 0) {
+          console.log('No migration files found.');
+          return;
+        }
+
+        console.log('Migration status:');
+
+        for (const filename of files) {
+          const status = applied.has(filename) ? 'applied' : 'pending';
+          console.log(`  [${status}] ${filename}`);
+        }
+      } finally {
+        await closePool();
+      }
+    }
+  },
+};
+
+export default commands;

package/src/{db.js → db.ts}

@@ -17,20 +17,29 @@
 import Cron from '@stonyx/cron';
 import config from 'stonyx/config';
 import log from 'stonyx/log';
-import Orm, { createRecord, store } from '@stonyx/orm';
+import Orm, { store } from '@stonyx/orm';
+import { createRecord } from './manage-record.js';
 import { createFile, createDirectory, updateFile, readFile, fileExists } from '@stonyx/utils/file';
 import path from 'path';
 
 export const dbKey = '__db';
 
+interface DBRecord {
+  format(): Record<string, unknown>;
+  [key: string]: unknown;
+}
+
 export default class DB {
+  static instance: DB;
+  record!: DBRecord;
+
   constructor() {
     if (DB.instance) return DB.instance;
 
     DB.instance = this;
   }
 
-  async getSchema() {
+  async getSchema(): Promise<unknown> {
     const { rootPath } = config;
     const { file, schema } = config.orm.db;
 
@@ -39,10 +48,10 @@ export default class DB {
     return (await import(`${rootPath}/${schema}`)).default;
   }
 
-  getCollectionKeys() {
-    const SchemaClass = Orm.instance.models[`${dbKey}Model`];
+  getCollectionKeys(): string[] {
+    const SchemaClass = (Orm.instance as Orm).models[`${dbKey}Model`] as new () => Record<string, unknown>;
     const instance = new SchemaClass();
-    const keys = [];
+    const keys: string[] = [];
 
     for (const key of Object.keys(instance)) {
       if (key === '__name' || key === 'id') continue;
@@ -52,7 +61,7 @@ export default class DB {
     return keys;
   }
 
-  getDirPath() {
+  getDirPath(): string {
     const { rootPath } = config;
     const { file, directory } = config.orm.db;
     const dbDir = path.dirname(path.resolve(`${rootPath}/${file}`));
@@ -60,7 +69,7 @@ export default class DB {
     return path.join(dbDir, directory);
   }
 
-  async validateMode() {
+  async validateMode(): Promise<void> {
     const { rootPath } = config;
     const { file, mode } = config.orm.db;
     const collectionKeys = this.getCollectionKeys();
@@ -71,11 +80,11 @@ export default class DB {
       const exists = await fileExists(dbFilePath);
 
       if (exists) {
-        const data = await readFile(dbFilePath, { json: true });
+        const data = await readFile(dbFilePath, { json: true }) as Record<string, unknown[]>;
         const hasData = collectionKeys.some(key => Array.isArray(data[key]) && data[key].length > 0);
 
         if (hasData) {
-          log.error(`DB mode mismatch: db.json contains data but mode is set to 'directory'. Run migration first:\n\n  stonyx db:migrate-to-directory\n`);
+          log.error!(`DB mode mismatch: db.json contains data but mode is set to 'directory'. Run migration first:\n\n  stonyx db:migrate-to-directory\n`);
           process.exit(1);
         }
       }
@@ -88,18 +97,18 @@ export default class DB {
         )).some(Boolean);
 
         if (hasCollectionFiles) {
-          log.error(`DB mode mismatch: directory '${config.orm.db.directory}/' contains collection files but mode is set to 'file'. Run migration first:\n\n  stonyx db:migrate-to-file\n`);
+          log.error!(`DB mode mismatch: directory '${config.orm.db.directory}/' contains collection files but mode is set to 'file'. Run migration first:\n\n  stonyx db:migrate-to-file\n`);
           process.exit(1);
         }
       }
     }
   }
 
-  async init() {
+  async init(): Promise<void> {
     const { autosave, saveInterval } = config.orm.db;
 
     store.set(dbKey, new Map());
-    Orm.instance.models[`${dbKey}Model`] = await this.getSchema();
+    (Orm.instance as Orm).models[`${dbKey}Model`] = await this.getSchema();
 
     await this.validateMode();
     this.record = await this.getRecord();
@@ -109,7 +118,7 @@ export default class DB {
     new Cron().register('save', this.save.bind(this), saveInterval);
   }
 
-  async create() {
+  async create(): Promise<Record<string, unknown>> {
     const { rootPath } = config;
     const { file, mode } = config.orm.db;
 
@@ -124,7 +133,7 @@ export default class DB {
       ));
 
       // Write empty-array skeleton to db.json
-      const skeleton = {};
+      const skeleton: Record<string, unknown[]> = {};
       for (const key of collectionKeys) skeleton[key] = [];
 
       await createFile(`${rootPath}/${file}`, skeleton, { json: true });
@@ -137,9 +146,9 @@ export default class DB {
     return {};
   }
 
-  async save() {
+  async save(): Promise<void> {
     const { file, mode } = config.orm.db;
-    const jsonData = this.record.format();
+    const jsonData = this.record.format() as Record<string, unknown>;
     delete jsonData.id; // Don't save id
 
     if (mode === 'directory') {
@@ -158,7 +167,7 @@ export default class DB {
       }));
 
       // Write empty-array skeleton to db.json
-      const skeleton = {};
+      const skeleton: Record<string, unknown[]> = {};
       for (const key of collectionKeys) skeleton[key] = [];
 
       const dbFilePath = `${config.rootPath}/${file}`;
@@ -167,16 +176,16 @@ export default class DB {
       if (dbFileExists) await updateFile(dbFilePath, skeleton, { json: true });
       else await createFile(dbFilePath, skeleton, { json: true });
 
-      log.db(`DB has been successfully saved to ${config.orm.db.directory}/ directory`);
+      log.db!(`DB has been successfully saved to ${config.orm.db.directory}/ directory`);
       return;
     }
 
     await updateFile(`${config.rootPath}/${file}`, jsonData, { json: true });
 
-    log.db(`DB has been successfully saved to ${file}`);
+    log.db!(`DB has been successfully saved to ${file}`);
   }
 
-  async getRecord() {
+  async getRecord(): Promise<DBRecord> {
     const { mode } = config.orm.db;
 
     if (mode === 'directory') return this.getRecordFromDirectory();
@@ -184,25 +193,25 @@ export default class DB {
     return this.getRecordFromFile();
   }
 
-  async getRecordFromFile() {
+  async getRecordFromFile(): Promise<DBRecord> {
     const { file } = config.orm.db;
 
     const data = await readFile(file, { json: true, missingFileCallback: this.create.bind(this) });
 
-    return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false });
+    return createRecord(dbKey, data as Record<string, unknown>, { isDbRecord: true, serialize: false, transform: false }) as unknown as DBRecord;
   }
 
-  async getRecordFromDirectory() {
+  async getRecordFromDirectory(): Promise<DBRecord> {
     const dirPath = this.getDirPath();
     const collectionKeys = this.getCollectionKeys();
     const dirExists = await fileExists(dirPath);
 
     if (!dirExists) {
       const data = await this.create();
-      return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false });
+      return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false }) as unknown as DBRecord;
     }
 
-    const assembled = {};
+    const assembled: Record<string, unknown> = {};
 
     await Promise.all(collectionKeys.map(async key => {
       const filePath = path.join(dirPath, `${key}.json`);
@@ -211,6 +220,6 @@ export default class DB {
       assembled[key] = exists ? await readFile(filePath, { json: true }) : [];
     }));
 
-    return createRecord(dbKey, assembled, { isDbRecord: true, serialize: false, transform: false });
+    return createRecord(dbKey, assembled, { isDbRecord: true, serialize: false, transform: false }) as unknown as DBRecord;
   }
 }

package/src/exports/db.ts

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

package/src/has-many.ts

@@ -0,0 +1,92 @@
+import { createRecord, store } from '@stonyx/orm';
+import { getRelationships, getGlobalRegistry, getPendingRegistry, getBelongsToRegistry } from './relationships.js';
+import { getOrSet, makeArray } from '@stonyx/utils/object';
+import { dbKey } from './db.js';
+import type { SourceRecord } from './types/orm-types.js';
+
+interface HasManyOptions {
+  global?: boolean;
+  [key: string]: unknown;
+}
+
+interface PendingItem {
+  pendingRelationship: Map<unknown, unknown[][]>;
+  id: unknown;
+}
+
+type RelationshipHandler = ((sourceRecord: SourceRecord, rawData: unknown, options: HasManyOptions) => unknown[]) & {
+  __relatedModelName: string;
+  __relationshipType: 'hasMany';
+};
+
+function queuePendingRelationship(
+  pendingRelationshipQueue: PendingItem[],
+  pendingRelationships: Map<string, Map<unknown, unknown[][]>>,
+  modelName: string,
+  id: unknown
+): null {
+  pendingRelationshipQueue.push({
+    pendingRelationship: getOrSet(pendingRelationships, modelName, new Map()),
+    id
+  });
+
+  return null;
+}
+
+export default function hasMany(modelName: string): RelationshipHandler {
+  const globalRelationships = getGlobalRegistry();
+  const pendingRelationships = getPendingRegistry();
+
+  const fn = (sourceRecord: SourceRecord, rawData: unknown, options: HasManyOptions): unknown[] => {
+    const { __name: sourceModelName } = sourceRecord.__model;
+    const relationshipId = sourceRecord.id;
+    const relationship = getRelationships('hasMany', sourceModelName, modelName, relationshipId as string) as Map<unknown, unknown[]>;
+    const modelStore = store.get(modelName);
+    const pendingRelationshipQueue: PendingItem[] = [];
+
+    const output: unknown[] = !rawData ? [] : makeArray(rawData).map((elementData: unknown) => {
+      let record: unknown;
+
+      if (typeof elementData !== 'object') {
+        if (!modelStore) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+
+        record = modelStore.get(elementData as number | string);
+
+        if (!record) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+      } else {
+        if (elementData !== Object(elementData)) {
+          return queuePendingRelationship(pendingRelationshipQueue, pendingRelationships, modelName, elementData);
+        }
+
+        record = createRecord(modelName, elementData as Record<string, unknown>, options);
+      }
+
+      // Populate belongTo side if the relationship is defined
+      const recordWithId = typeof record === 'object' && record !== null && 'id' in record ? record as SourceRecord : undefined;
+      const otherSide = recordWithId ? getBelongsToRegistry()
+        .get(modelName)?.get(sourceModelName)?.get(recordWithId.id) : undefined;
+
+      if (otherSide) Object.assign(otherSide, sourceRecord);
+
+      return record;
+    }).filter((value: unknown) => 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;
+  };
+
+  Object.defineProperty(fn, '__relatedModelName', { value: modelName });
+  Object.defineProperty(fn, '__relationshipType', { value: 'hasMany' as const });
+  return fn as RelationshipHandler;
+}