@stonyx/orm 0.2.1-beta.87 → 0.2.1-beta.89

package/dist/postgres/postgres-db.js

@@ -56,20 +56,20 @@ export default class PostgresDB {
         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.`);
+            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.requirePool(), filename, up, this.pgConfig.migrationsTable);
-                    this.deps.log.db(`Applied migration: ${filename}`);
+                    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.');
+                this.deps.log.warn?.('Skipping pending migrations. Schema may be outdated.');
             }
         }
         else if (files.length === 0) {
@@ -83,12 +83,12 @@ export default class PostgresDB {
                     if (result) {
                         const { up } = this.deps.parseMigrationFile(result.content);
                         await this.deps.applyMigration(this.requirePool(), result.filename, up, this.pgConfig.migrationsTable);
-                        this.deps.log.db(`Applied migration: ${result.filename}`);
+                        this.deps.log.db?.(`Applied migration: ${result.filename}`);
                         await this.loadMemoryRecords();
                     }
                 }
                 else {
-                    this.deps.log.warn('Skipping initial migration. Tables may not exist.');
+                    this.deps.log.warn?.('Skipping initial migration. Tables may not exist.');
                 }
             }
         }
@@ -98,8 +98,8 @@ export default class PostgresDB {
         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.');
+                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.');
             }
         }
     }
@@ -121,7 +121,7 @@ export default class PostgresDB {
         for (const modelName of order) {
             const { modelClass } = Orm.instance.getRecordClasses(modelName);
             if (modelClass?.memory === false) {
-                this.deps.log.db(`Skipping memory load for '${modelName}' (memory: false)`);
+                this.deps.log.db?.(`Skipping memory load for '${modelName}' (memory: false)`);
                 continue;
             }
             const schema = schemas[modelName];
@@ -136,7 +136,7 @@ export default class PostgresDB {
             catch (error) {
                 // 42P01 = undefined_table (PG equivalent of ER_NO_SUCH_TABLE)
                 if (isDbError(error) && error.code === '42P01') {
-                    this.deps.log.db(`Table '${schema.table}' does not exist yet. Skipping load for '${modelName}'.`);
+                    this.deps.log.db?.(`Table '${schema.table}' does not exist yet. Skipping load for '${modelName}'.`);
                     continue;
                 }
                 throw error;
@@ -147,7 +147,7 @@ export default class PostgresDB {
         for (const [viewName, viewSchema] of Object.entries(viewSchemas)) {
             const { modelClass: viewClass } = Orm.instance.getRecordClasses(viewName);
             if (viewClass?.memory !== true) {
-                this.deps.log.db(`Skipping memory load for view '${viewName}' (memory: false)`);
+                this.deps.log.db?.(`Skipping memory load for view '${viewName}' (memory: false)`);
                 continue;
             }
             const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
@@ -170,7 +170,7 @@ export default class PostgresDB {
             }
             catch (error) {
                 if (isDbError(error) && error.code === '42P01') {
-                    this.deps.log.db(`View '${viewSchema.viewName}' does not exist yet. Skipping load for '${viewName}'.`);
+                    this.deps.log.db?.(`View '${viewSchema.viewName}' does not exist yet. Skipping load for '${viewName}'.`);
                     continue;
                 }
                 throw error;
@@ -250,11 +250,12 @@ export default class PostgresDB {
         }
         if (!schema)
             return [];
-        const { sql, values } = this.deps.buildSelect(schema.table, conditions);
+        const resolvedSchema = schema;
+        const { sql, values } = this.deps.buildSelect(resolvedSchema.table, conditions);
         try {
             const result = await this.requirePool().query(sql, values);
             const records = result.rows.map(row => {
-                const rawData = this._rowToRawData(row, schema);
+                const rawData = this._rowToRawData(row, resolvedSchema);
                 return this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false });
             });
             for (const record of records) {

package/dist/postgres/schema-introspector.js

@@ -60,6 +60,8 @@ export function introspectModels() {
         }
         // Build foreign keys from belongsTo relationships
         for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
+            if (!targetModelName)
+                continue;
             const fkColumn = `${relName}_id`;
             foreignKeys[fkColumn] = {
                 references: sanitizeTableName(getPluralName(targetModelName)),
@@ -139,7 +141,8 @@ export function getTopologicalOrder(schemas) {
             return;
         // Visit dependencies (belongsTo targets) first
         for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
-            visit(targetModelName);
+            if (targetModelName)
+                visit(targetModelName);
         }
         order.push(name);
     }
@@ -175,11 +178,13 @@ export function introspectViews() {
             const relInfo = getRelationshipInfo(property);
             if (relInfo?.type === 'belongsTo') {
                 relationships.belongsTo[key] = relInfo.modelName;
-                const fkColumn = `${key}_id`;
-                foreignKeys[fkColumn] = {
-                    references: sanitizeTableName(getPluralName(relInfo.modelName)),
-                    column: 'id',
-                };
+                if (relInfo.modelName) {
+                    const fkColumn = `${key}_id`;
+                    foreignKeys[fkColumn] = {
+                        references: sanitizeTableName(getPluralName(relInfo.modelName)),
+                        column: 'id',
+                    };
+                }
             }
             else if (relInfo?.type === 'hasMany') {
                 relationships.hasMany[key] = relInfo.modelName;

package/dist/relationships.js

@@ -10,6 +10,8 @@ export function getRelationships(type, sourceModel, targetModel, relationshipId)
     if (!allRelationships.has(sourceModel))
         allRelationships.set(sourceModel, new Map());
     const modelRelationship = allRelationships.get(sourceModel);
+    if (!modelRelationship)
+        return undefined;
     if (!modelRelationship.has(targetModel))
         modelRelationship.set(targetModel, new Map());
     const relationship = modelRelationship.get(targetModel);

package/dist/setup-rest-server.js

@@ -8,7 +8,7 @@ import { dbKey } from './db.js';
 import { getPluralName } from './plural-registry.js';
 import log from 'stonyx/log';
 export default async function (route, accessPath, metaRoute) {
-    let accessFiles = {};
+    const accessFiles = {};
     try {
         await forEachFileImport(accessPath, (accessClass) => {
             const accessInstance = new accessClass();
@@ -32,8 +32,8 @@ export default async function (route, accessPath, metaRoute) {
         });
     }
     catch (error) {
-        log.error(error instanceof Error ? error.message : String(error));
-        log.warn('You must define a valid access configuration file in order to access ORM generated REST endpoints.');
+        log.error?.(error instanceof Error ? error.message : String(error));
+        log.warn?.('You must define a valid access configuration file in order to access ORM generated REST endpoints.');
     }
     await waitForModule('rest-server');
     // Remove "/" prefix and name mount point accordingly
@@ -46,9 +46,7 @@ export default async function (route, accessPath, metaRoute) {
     }
     // Mount the meta route when metaRoute config is enabled
     if (metaRoute) {
-        log.warn('SECURITY RISK! - Meta route is enabled via metaRoute config. This feature is intended for development purposes only!');
+        log.warn?.('SECURITY RISK! - Meta route is enabled via metaRoute config. This feature is intended for development purposes only!');
         RestServer.instance.mountRoute(MetaRequest, { name });
     }
-    // Cleanup references
-    accessFiles = null;
 }

package/dist/store.js

@@ -1,6 +1,9 @@
 import Orm, { relationships } from '@stonyx/orm';
 import { TYPES, getHasManyRegistry, getBelongsToRegistry, getPendingRegistry } from './relationships.js';
 import ViewResolver from './view-resolver.js';
+function isStoreRecord(value) {
+    return typeof value === 'object' && value !== null && '__data' in value;
+}
 export default class Store {
     static instance;
     data = new Map();
@@ -55,7 +58,7 @@ export default class Store {
             const records = await resolver.resolveAll();
             if (!conditions || Object.keys(conditions).length === 0)
                 return records;
-            return records.filter((record) => Object.entries(conditions).every(([key, value]) => record.__data[key] === value));
+            return records.filter((record) => Object.entries(conditions).every(([key, value]) => isStoreRecord(record) && record.__data[key] === value));
         }
         // For memory: true models without conditions, return from store
         if (this._isMemoryModel(modelName) && !conditions) {
@@ -73,7 +76,7 @@ export default class Store {
         const records = Array.from(modelStore.values());
         if (!conditions || Object.keys(conditions).length === 0)
             return records;
-        return records.filter((record) => Object.entries(conditions).every(([key, value]) => record.__data[key] === value));
+        return records.filter((record) => Object.entries(conditions).every(([key, value]) => isStoreRecord(record) && record.__data[key] === value));
     }
     /**
      * Async query — always hits MySQL, never reads from memory cache.
@@ -90,7 +93,7 @@ export default class Store {
         const records = Array.from(modelStore.values());
         if (Object.keys(conditions).length === 0)
             return records;
-        return records.filter((record) => Object.entries(conditions).every(([key, value]) => record.__data[key] === value));
+        return records.filter((record) => Object.entries(conditions).every(([key, value]) => isStoreRecord(record) && record.__data[key] === value));
     }
     /**
      * Check if a model is configured for in-memory storage.
@@ -119,11 +122,14 @@ export default class Store {
             console.warn(`[Store] Cannot unload record: model "${model}" not found in store`);
             return;
         }
-        const record = modelStore.get(id);
-        if (!record) {
+        if (typeof id !== 'string' && typeof id !== 'number')
+            return;
+        const raw = modelStore.get(id);
+        if (!raw || !isStoreRecord(raw)) {
             console.warn(`[Store] Cannot unload record: ${model}:${id} not found in store`);
             return;
         }
+        const record = raw;
         const { toUnload, visited } = options.includeChildren
             ? this._buildUnloadQueue(record, options)
             : { toUnload: [{ record, modelName: model, recordId: id }], visited: new Set([`${model}:${id}`]) };
@@ -148,8 +154,11 @@ export default class Store {
                 this.unloadRecord(model, id, options);
             }
         }
-        for (const relationshipType of TYPES)
-            relationships.get(relationshipType).delete(model);
+        for (const relationshipType of TYPES) {
+            const reg = relationships.get(relationshipType);
+            if (reg instanceof Map)
+                reg.delete(model);
+        }
     }
     _removeFromHasManyArrays(modelName, recordId, visited) {
         const hasManyRegistry = getHasManyRegistry();
@@ -162,7 +171,7 @@ export default class Store {
                 // Don't modify arrays of records being deleted
                 if (visited.has(sourceKey))
                     continue;
-                const index = hasManyArray.findIndex(r => r && r.id === recordId);
+                const index = hasManyArray.findIndex(r => r && isStoreRecord(r) && r.id === recordId);
                 if (index !== -1)
                     hasManyArray.splice(index, 1);
             }
@@ -175,16 +184,20 @@ export default class Store {
             if (!targetModelMap)
                 continue;
             for (const [sourceRecordId, belongsToRecord] of targetModelMap) {
-                if (belongsToRecord && belongsToRecord.id === recordId) {
+                if (belongsToRecord && isStoreRecord(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;
+                    if (typeof sourceRecordId !== 'string' && typeof sourceRecordId !== 'number')
+                        continue;
+                    const sourceRaw = this.get(sourceModel, sourceRecordId);
+                    if (!sourceRaw || !isStoreRecord(sourceRaw))
+                        continue;
+                    if (sourceRaw.__relationships) {
+                        for (const [key, value] of Object.entries(sourceRaw.__relationships)) {
+                            if (value && isStoreRecord(value) && value.id === recordId) {
+                                sourceRaw.__relationships[key] = null;
                             }
                         }
                     }
@@ -219,11 +232,11 @@ export default class Store {
             // hasMany children - always include
             if (Array.isArray(value)) {
                 for (const childRecord of value) {
-                    if (childRecord)
-                        children.push({ childRecord: childRecord, relationshipKey: key, type: 'hasMany' });
+                    if (childRecord && isStoreRecord(childRecord))
+                        children.push({ childRecord, relationshipKey: key, type: 'hasMany' });
                 }
             }
-            else if (value && !this._isBidirectionalRelationship(record.__model.__name, value.__model.__name)) {
+            else if (value && isStoreRecord(value) && value.__model && !this._isBidirectionalRelationship(record.__model.__name, value.__model.__name)) {
                 children.push({ childRecord: value, relationshipKey: key, type: 'belongsTo' });
             }
         }
@@ -245,6 +258,8 @@ export default class Store {
             }];
         while (queue.length > 0) {
             const item = queue.shift();
+            if (!item)
+                break;
             const key = `${item.modelName}:${item.recordId}`;
             if (visited.has(key))
                 continue;

package/dist/utils.d.ts

@@ -1,5 +1,7 @@
+import type { OrmRecord } from './types/orm-types.js';
 export declare function isDbError(error: unknown): error is {
     code: string;
     message: string;
 };
+export declare function isOrmRecord(value: unknown): value is OrmRecord;
 export declare function pluralize(word: string): string;

package/dist/utils.js

@@ -2,11 +2,15 @@ import { pluralize as basePluralize } from '@stonyx/utils/string';
 export function isDbError(error) {
     return typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' && 'message' in error && typeof error.message === 'string';
 }
+export function isOrmRecord(value) {
+    return typeof value === 'object' && value !== null && '__data' in value && '__relationships' in value;
+}
 // 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());
+        const last = parts.pop();
+        const pluralizedLast = basePluralize(last);
         return [...parts, pluralizedLast].join('-');
     }
     return basePluralize(word);

package/dist/view-resolver.js

@@ -101,7 +101,9 @@ export default class ViewResolver {
             if (!groups.has(key)) {
                 groups.set(key, []);
             }
-            groups.get(key).push(record);
+            const group = groups.get(key);
+            if (group)
+                group.push(record);
         }
         const results = [];
         for (const [groupKey, groupRecords] of groups) {

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.2.1-beta.87",
+  "version": "0.2.1-beta.89",
   "description": "",
   "main": "dist/index.js",
   "type": "module",

package/src/aggregates.ts

@@ -27,13 +27,15 @@ export class AggregateProperty {
       return 0;
     }
 
-    switch (this.aggregateType) {
-      case 'count':
-        return relatedRecords.length;
+    if (this.aggregateType === 'count') return relatedRecords.length;
+
+    const field = this.field;
+    if (!field) return null;
 
+    switch (this.aggregateType) {
       case 'sum':
         return relatedRecords.reduce((acc, record) => {
-          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
           return acc + (isNaN(val) ? 0 : val);
         }, 0);
 
@@ -41,7 +43,7 @@ export class AggregateProperty {
         let sum = 0;
         let count = 0;
         for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
           if (!isNaN(val)) {
             sum += val;
             count++;
@@ -53,7 +55,7 @@ export class AggregateProperty {
       case 'min': {
         let min: number | null = null;
         for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
           if (!isNaN(val) && (min === null || val < min)) min = val;
         }
         return min;
@@ -62,7 +64,7 @@ export class AggregateProperty {
       case 'max': {
         let max: number | null = null;
         for (const record of relatedRecords) {
-          const val = parseFloat(record?.__data?.[this.field!] as string ?? record?.[this.field!] as string);
+          const val = parseFloat(record?.__data?.[field] as string ?? record?.[field] as string);
           if (!isNaN(val) && (max === null || val > max)) max = val;
         }
         return max;

package/src/belongs-to.ts

@@ -4,7 +4,7 @@ import type { SourceRecord } from './types/orm-types.js';
 
 function getOrSet<K, V>(map: Map<K, V>, key: K, defaultValue: V): V {
   if (!map.has(key)) map.set(key, defaultValue);
-  return map.get(key)!;
+  return map.get(key) as V;
 }
 
 interface BelongsToOptions {

package/src/db.ts

@@ -29,6 +29,13 @@ interface DBRecord {
   [key: string]: unknown;
 }
 
+function asDBRecord(value: unknown): DBRecord {
+  if (typeof value !== 'object' || value === null || typeof (value as DBRecord).format !== 'function') {
+    throw new Error('createRecord did not return a valid DBRecord');
+  }
+  return value as DBRecord;
+}
+
 export default class DB {
   static instance: DB;
   record!: DBRecord;
@@ -49,7 +56,7 @@ export default class DB {
   }
 
   getCollectionKeys(): string[] {
-    const SchemaClass = (Orm.instance as Orm).models[`${dbKey}Model`] as new () => Record<string, unknown>;
+    const SchemaClass = Orm.instance.models[`${dbKey}Model`] as new () => Record<string, unknown>;
     const instance = new SchemaClass();
     const keys: string[] = [];
 
@@ -84,7 +91,7 @@ export default class DB {
         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);
         }
       }
@@ -97,7 +104,7 @@ 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);
         }
       }
@@ -108,7 +115,7 @@ export default class DB {
     const { autosave, saveInterval } = config.orm.db;
 
     store.set(dbKey, new Map());
-    (Orm.instance as Orm).models[`${dbKey}Model`] = await this.getSchema();
+    Orm.instance.models[`${dbKey}Model`] = await this.getSchema();
 
     await this.validateMode();
     this.record = await this.getRecord();
@@ -176,13 +183,13 @@ 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(): Promise<DBRecord> {
@@ -198,7 +205,7 @@ export default class DB {
 
     const data = await readFile(file, { json: true, missingFileCallback: this.create.bind(this) });
 
-    return createRecord(dbKey, data as Record<string, unknown>, { isDbRecord: true, serialize: false, transform: false }) as unknown as DBRecord;
+    return asDBRecord(createRecord(dbKey, data as Record<string, unknown>, { isDbRecord: true, serialize: false, transform: false }));
   }
 
   async getRecordFromDirectory(): Promise<DBRecord> {
@@ -208,7 +215,7 @@ export default class DB {
 
     if (!dirExists) {
       const data = await this.create();
-      return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false }) as unknown as DBRecord;
+      return asDBRecord(createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false }));
     }
 
     const assembled: Record<string, unknown> = {};
@@ -220,6 +227,6 @@ export default class DB {
       assembled[key] = exists ? await readFile(filePath, { json: true }) : [];
     }));
 
-    return createRecord(dbKey, assembled, { isDbRecord: true, serialize: false, transform: false }) as unknown as DBRecord;
+    return asDBRecord(createRecord(dbKey, assembled, { isDbRecord: true, serialize: false, transform: false }));
   }
 }

package/src/hooks.ts

@@ -40,7 +40,8 @@ export function beforeHook(operation: string, model: string, handler: HookHandle
   if (!beforeHooks.has(key)) {
     beforeHooks.set(key, []);
   }
-  beforeHooks.get(key)!.push(handler);
+  const hooks = beforeHooks.get(key);
+  if (hooks) hooks.push(handler);
 
   // Return unsubscribe function
   return () => {
@@ -66,7 +67,8 @@ export function afterHook(operation: string, model: string, handler: HookHandler
   if (!afterHooks.has(key)) {
     afterHooks.set(key, []);
   }
-  afterHooks.get(key)!.push(handler);
+  const hooks = afterHooks.get(key);
+  if (hooks) hooks.push(handler);
 
   // Return unsubscribe function
   return () => {

package/src/main.ts

@@ -187,7 +187,8 @@ export default class Orm {
   static get db(): OrmDB | SqlDb {
     if (!Orm.initialized) throw new Error('ORM has not been initialized yet');
 
-    return Orm.instance.db!;
+    if (!Orm.instance.db) throw new Error('ORM database has not been initialized');
+    return Orm.instance.db;
   }
 
   getRecordClasses(modelName: string): { modelClass: unknown; serializerClass: unknown } {
@@ -218,7 +219,7 @@ export default class Orm {
     this.warnings.add(message);
 
     setTimeout(() => {
-      this.warnings.forEach(warning => log.warn!(warning));
+      this.warnings.forEach(warning => log.warn?.(warning));
       this.warnings.clear();
     }, 0);
   }

package/src/manage-record.ts

@@ -2,6 +2,7 @@ import Orm, { store } from '@stonyx/orm';
 import OrmRecord from './record.js';
 import { getGlobalRegistry, getPendingRegistry, getPendingBelongsToRegistry, getBelongsToRegistry, getHasManyRegistry } from './relationships.js';
 import type Serializer from './serializer.js';
+import { isOrmRecord } from './utils.js';
 
 interface CreateRecordOptions {
   isDbRecord?: boolean;
@@ -45,10 +46,10 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
   assignRecordId(modelName, rawData);
   const existingRecord = modelStore.get(rawData.id as number | string);
 
-  if (existingRecord) {
+  if (existingRecord instanceof OrmRecord) {
     // Update the existing record with new data so the last entry wins
-    updateRecord(existingRecord as OrmRecord, rawData, { ...options, update: true });
-    return existingRecord as OrmRecord;
+    updateRecord(existingRecord, rawData, { ...options, update: true });
+    return existingRecord;
   }
 
   const recordClasses = orm.getRecordClasses(modelName);
@@ -77,7 +78,8 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
 
   // Fulfill pending belongsTo relationships
   const pendingBelongsToQueue = getPendingBelongsToRegistry();
-  const pendingBelongsTo = pendingBelongsToQueue.get(modelName)?.get(record.id) as PendingBelongsToEntry[] | undefined;
+  const pendingBelongsToRaw = pendingBelongsToQueue.get(modelName)?.get(record.id);
+  const pendingBelongsTo = Array.isArray(pendingBelongsToRaw) ? pendingBelongsToRaw as PendingBelongsToEntry[] : undefined;
 
   if (pendingBelongsTo) {
     const belongsToReg = getBelongsToRegistry();
@@ -142,8 +144,11 @@ function assignRecordId(modelName: string, rawData: { [key: string]: unknown }):
     return;
   }
 
-  const modelStore = Array.from(store.get(modelName)!.values()) as OrmRecord[];
-  rawData.id = modelStore.length ? (modelStore.at(-1)!.id as number) + 1 : 1;
+  const storeMap = store.get(modelName);
+  if (!storeMap) throw new Error(`Cannot assign record ID: model "${modelName}" not found in store`);
+  const modelStore = Array.from(storeMap.values()).filter(isOrmRecord);
+  const lastRecord = modelStore.at(-1);
+  rawData.id = lastRecord ? (lastRecord.id as number) + 1 : 1;
 }
 
 function isStringIdModel(modelName: string): boolean {

package/src/mysql/migration-generator.ts

@@ -51,9 +51,12 @@ interface GeneratedMigration {
 type Snapshot = Record<string, SnapshotEntry & { isView?: boolean; viewName?: string; viewQuery?: string; source?: string }>;
 
 export async function generateMigration(description: string = 'migration'): Promise<GeneratedMigration | null> {
-  const { migrationsDir } = config.orm.mysql!;
+  const mysqlConfig = config.orm.mysql;
+  if (!mysqlConfig) throw new Error('MySQL configuration (config.orm.mysql) is required for migration generation');
+  const { migrationsDir } = mysqlConfig;
+  if (!migrationsDir) throw new Error('MySQL migrationsDir is required in config');
   const rootPath = config.rootPath;
-  const migrationsPath = path.resolve(rootPath, migrationsDir!);
+  const migrationsPath = path.resolve(rootPath, migrationsDir);
 
   await createDirectory(migrationsPath);
 
@@ -71,7 +74,7 @@ export async function generateMigration(description: string = 'migration'): Prom
     const viewDiffPrelim = diffViewSnapshots(previousViewSnapshotPrelim, currentViewSnapshotPrelim);
 
     if (!viewDiffPrelim.hasChanges) {
-      log.db!('No schema changes detected.');
+      log.db?.('No schema changes detected.');
       return null;
     }
   }
@@ -104,7 +107,8 @@ export async function generateMigration(description: string = 'migration'): Prom
 
   // Removed columns
   for (const { model, column, type } of diff.removedColumns) {
-    const table = previousSnapshot[model].table!;
+    const table = previousSnapshot[model]?.table;
+    if (!table) throw new Error(`Missing table name in snapshot for model "${model}"`);
     upStatements.push(`ALTER TABLE \`${table}\` DROP COLUMN \`${column}\`;`);
     downStatements.push(`ALTER TABLE \`${table}\` ADD COLUMN \`${column}\` ${type};`);
   }
@@ -130,7 +134,8 @@ export async function generateMigration(description: string = 'migration'): Prom
 
   // Removed foreign keys
   for (const { model, column, references } of diff.removedForeignKeys) {
-    const table = previousSnapshot[model].table!;
+    const table = previousSnapshot[model]?.table;
+    if (!table) throw new Error(`Missing table name in snapshot for model "${model}"`);
     // 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';
@@ -184,7 +189,7 @@ export async function generateMigration(description: string = 'migration'): Prom
   const combinedHasChanges = diff.hasChanges || viewDiff.hasChanges;
 
   if (!combinedHasChanges) {
-    log.db!('No schema changes detected.');
+    log.db?.('No schema changes detected.');
     return null;
   }
 
@@ -202,7 +207,7 @@ export async function generateMigration(description: string = 'migration'): Prom
   await createFile(path.join(migrationsPath, filename), content);
   await createFile(path.join(migrationsPath, '.snapshot.json'), JSON.stringify(combinedSnapshot, null, 2));
 
-  log.db!(`Migration generated: ${filename}`);
+  log.db?.(`Migration generated: ${filename}`);
 
   return { filename, content, snapshot: combinedSnapshot };
 }