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

package/dist/db.js

@@ -21,6 +21,12 @@ import { createRecord } from './manage-record.js';
 import { createFile, createDirectory, updateFile, readFile, fileExists } from '@stonyx/utils/file';
 import path from 'path';
 export const dbKey = '__db';
+function asDBRecord(value) {
+    if (typeof value !== 'object' || value === null || typeof value.format !== 'function') {
+        throw new Error('createRecord did not return a valid DBRecord');
+    }
+    return value;
+}
 export default class DB {
     static instance;
     record;
@@ -153,7 +159,7 @@ export default class DB {
     async getRecordFromFile() {
         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 asDBRecord(createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false }));
     }
     async getRecordFromDirectory() {
         const dirPath = this.getDirPath();
@@ -161,7 +167,7 @@ export default class DB {
         const dirExists = await fileExists(dirPath);
         if (!dirExists) {
             const data = await this.create();
-            return createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false });
+            return asDBRecord(createRecord(dbKey, data, { isDbRecord: true, serialize: false, transform: false }));
         }
         const assembled = {};
         await Promise.all(collectionKeys.map(async (key) => {
@@ -169,6 +175,6 @@ export default class DB {
             const exists = await fileExists(filePath);
             assembled[key] = exists ? await readFile(filePath, { json: true }) : [];
         }));
-        return createRecord(dbKey, assembled, { isDbRecord: true, serialize: false, transform: false });
+        return asDBRecord(createRecord(dbKey, assembled, { isDbRecord: true, serialize: false, transform: false }));
     }
 }

package/dist/manage-record.js

@@ -1,6 +1,7 @@
 import Orm, { store } from '@stonyx/orm';
 import OrmRecord from './record.js';
 import { getGlobalRegistry, getPendingRegistry, getPendingBelongsToRegistry, getBelongsToRegistry, getHasManyRegistry } from './relationships.js';
+import { isOrmRecord } from './utils.js';
 const defaultOptions = {
     isDbRecord: false,
     serialize: true,
@@ -23,7 +24,7 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
         throw new Error(`Model store for '${modelName}' is not registered. Ensure the model is defined before creating records.`);
     assignRecordId(modelName, rawData);
     const existingRecord = modelStore.get(rawData.id);
-    if (existingRecord) {
+    if (existingRecord instanceof OrmRecord) {
         // Update the existing record with new data so the last entry wins
         updateRecord(existingRecord, rawData, { ...options, update: true });
         return existingRecord;
@@ -52,7 +53,8 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
     }
     // Fulfill pending belongsTo relationships
     const pendingBelongsToQueue = getPendingBelongsToRegistry();
-    const pendingBelongsTo = pendingBelongsToQueue.get(modelName)?.get(record.id);
+    const pendingBelongsToRaw = pendingBelongsToQueue.get(modelName)?.get(record.id);
+    const pendingBelongsTo = Array.isArray(pendingBelongsToRaw) ? pendingBelongsToRaw : undefined;
     if (pendingBelongsTo) {
         const belongsToReg = getBelongsToRegistry();
         const hasManyReg = getHasManyRegistry();
@@ -108,7 +110,7 @@ function assignRecordId(modelName, rawData) {
     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());
+    const modelStore = Array.from(storeMap.values()).filter(isOrmRecord);
     const lastRecord = modelStore.at(-1);
     rawData.id = lastRecord ? lastRecord.id + 1 : 1;
 }

package/dist/orm-request.js

@@ -4,6 +4,7 @@ import { camelCaseToKebabCase } from '@stonyx/utils/string';
 import { getPluralName } from './plural-registry.js';
 import { getBeforeHooks, getAfterHooks } from './hooks.js';
 import config from 'stonyx/config';
+import { isOrmRecord } from './utils.js';
 const methodAccessMap = {
     GET: 'read',
     POST: 'create',
@@ -91,8 +92,8 @@ function traverseIncludePath(currentRecords, includePath, depth, seen, included)
             continue;
         // Handle both belongsTo (single) and hasMany (array)
         const recordsToProcess = Array.isArray(relatedRecords)
-            ? relatedRecords
-            : [relatedRecords];
+            ? relatedRecords.filter(isOrmRecord)
+            : isOrmRecord(relatedRecords) ? [relatedRecords] : [];
         for (const relatedRecord of recordsToProcess) {
             if (!relatedRecord)
                 continue;
@@ -198,7 +199,7 @@ export default class OrmRequest extends Request {
         const modelRelationships = getModelRelationships(model);
         // Define raw handlers first
         const getCollectionHandler = async (request, { filter: accessFilter }) => {
-            const allRecords = await store.findAll(model);
+            const allRecords = (await store.findAll(model)).filter(isOrmRecord);
             const queryFilters = parseFilters(request.query);
             const queryFilterPredicate = createFilterPredicate(queryFilters);
             const fieldsMap = parseFields(request.query);
@@ -247,11 +248,17 @@ export default class OrmRequest extends Request {
                 }
             }
             const recordAttributes = id !== undefined ? { id, ...sanitizedAttributes } : sanitizedAttributes;
-            const record = createRecord(model, recordAttributes, { serialize: false });
+            const created = createRecord(model, recordAttributes, { serialize: false });
+            const record = isOrmRecord(created) ? created : null;
+            if (!record)
+                return 500;
             return { data: record.toJSON?.({ fields: modelFields }) };
         };
         const updateHandler = async ({ body, params }) => {
-            const record = await store.find(model, getId(params));
+            const found = await store.find(model, getId(params));
+            if (!found || !isOrmRecord(found))
+                return 404;
+            const record = found;
             const { attributes, relationships: rels } = (body?.data || {});
             if (!attributes && !rels)
                 return 400; // Bad request
@@ -393,11 +400,12 @@ export default class OrmRequest extends Request {
                 let data;
                 if (info.isArray) {
                     // hasMany - return array
-                    data = (relatedData || []).map(r => r.toJSON?.({ baseUrl }));
+                    const related = Array.isArray(relatedData) ? relatedData.filter(isOrmRecord) : [];
+                    data = related.map(r => r.toJSON?.({ baseUrl }));
                 }
                 else {
                     // belongsTo - return single or null
-                    data = relatedData ? relatedData.toJSON?.({ baseUrl }) : null;
+                    data = isOrmRecord(relatedData) ? relatedData.toJSON?.({ baseUrl }) : null;
                 }
                 return {
                     links: { self: `${baseUrl}/${pluralizedModel}/${request.params.id}/${dasherizedName}` },
@@ -414,16 +422,19 @@ export default class OrmRequest extends Request {
                 let data;
                 if (info.isArray) {
                     // hasMany - return array of linkage objects
-                    data = (relatedData || [])
+                    const related = Array.isArray(relatedData) ? relatedData.filter(isOrmRecord) : [];
+                    data = related
                         .filter((r) => Boolean(r.__model))
                         .map(r => ({ type: r.__model.__name, id: r.id }));
                 }
                 else {
                     // belongsTo - return single linkage or null
-                    const model = relatedData ? relatedData.__model : undefined;
-                    data = model
-                        ? { type: model.__name, id: relatedData.id }
-                        : null;
+                    if (isOrmRecord(relatedData) && relatedData.__model) {
+                        data = { type: relatedData.__model.__name, id: relatedData.id };
+                    }
+                    else {
+                        data = null;
+                    }
                 }
                 return {
                     links: {

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

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,6 +2,9 @@ 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('-')) {

package/package.json

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

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[] = [];
 
@@ -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();
@@ -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/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();
@@ -144,7 +146,7 @@ function assignRecordId(modelName: string, rawData: { [key: string]: unknown }):
 
   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()) as OrmRecord[];
+  const modelStore = Array.from(storeMap.values()).filter(isOrmRecord);
   const lastRecord = modelStore.at(-1);
   rawData.id = lastRecord ? (lastRecord.id as number) + 1 : 1;
 }

package/src/orm-request.ts

@@ -5,6 +5,7 @@ import { getPluralName } from './plural-registry.js';
 import { getBeforeHooks, getAfterHooks } from './hooks.js';
 import config from 'stonyx/config';
 import type { OrmRecord } from './types/orm-types.js';
+import { isOrmRecord } from './utils.js';
 
 interface OrmRequest$ extends Request {
   protocol?: string;
@@ -74,7 +75,7 @@ function getRelationshipInfo(property: unknown): RelationshipInfo | null {
 
 // Helper to introspect model relationships
 function getModelRelationships(modelName: string): { [key: string]: RelationshipInfo } {
-  const { modelClass } = (Orm.instance as Orm).getRecordClasses(modelName);
+  const { modelClass } = Orm.instance.getRecordClasses(modelName);
   if (!modelClass) return {};
 
   const model = new (modelClass as new (name: string) => { [key: string]: unknown })(modelName);
@@ -157,8 +158,8 @@ function traverseIncludePath(
 
     // Handle both belongsTo (single) and hasMany (array)
     const recordsToProcess: OrmRecord[] = Array.isArray(relatedRecords)
-      ? relatedRecords as OrmRecord[]
-      : [relatedRecords as OrmRecord];
+      ? relatedRecords.filter(isOrmRecord)
+      : isOrmRecord(relatedRecords) ? [relatedRecords] : [];
 
     for (const relatedRecord of recordsToProcess) {
       if (!relatedRecord) continue;
@@ -281,7 +282,7 @@ export default class OrmRequest extends Request {
 
     // Define raw handlers first
     const getCollectionHandler: HandlerFn = async (request, { filter: accessFilter }) => {
-      const allRecords = await store.findAll(model) as OrmRecord[];
+      const allRecords = (await store.findAll(model)).filter(isOrmRecord);
 
       const queryFilters = parseFilters(request.query);
       const queryFilterPredicate = createFilterPredicate(queryFilters);
@@ -344,13 +345,17 @@ export default class OrmRequest extends Request {
       }
 
       const recordAttributes = id !== undefined ? { id, ...sanitizedAttributes } : sanitizedAttributes;
-      const record = createRecord(model, recordAttributes as { [key: string]: unknown }, { serialize: false }) as unknown as OrmRecord;
+      const created = createRecord(model, recordAttributes as { [key: string]: unknown }, { serialize: false });
+      const record = isOrmRecord(created) ? created : null;
+      if (!record) return 500;
 
       return { data: record.toJSON?.({ fields: modelFields }) };
     };
 
     const updateHandler: HandlerFn = async ({ body, params }) => {
-      const record = await store.find(model, getId(params)) as OrmRecord;
+      const found = await store.find(model, getId(params));
+      if (!found || !isOrmRecord(found)) return 404;
+      const record = found;
       const { attributes, relationships: rels } = (body?.data || {}) as {
         attributes?: { [key: string]: unknown };
         relationships?: { [key: string]: { data?: { id?: string | number } } };
@@ -454,7 +459,7 @@ export default class OrmRequest extends Request {
       const response = await handler(request, state);
 
       // Persist to SQL database for write operations
-      const sqlDb = (Orm.instance as Orm).sqlDb;
+      const sqlDb = Orm.instance.sqlDb;
       if (sqlDb && WRITE_OPERATIONS.has(operation)) {
         await sqlDb.persist(operation, this.model, context, response);
       }
@@ -514,10 +519,11 @@ export default class OrmRequest extends Request {
         let data: unknown;
         if (info.isArray) {
           // hasMany - return array
-          data = ((relatedData || []) as OrmRecord[]).map(r => r.toJSON?.({ baseUrl }));
+          const related = Array.isArray(relatedData) ? relatedData.filter(isOrmRecord) : [];
+          data = related.map(r => r.toJSON?.({ baseUrl }));
         } else {
           // belongsTo - return single or null
-          data = relatedData ? (relatedData as OrmRecord).toJSON?.({ baseUrl }) : null;
+          data = isOrmRecord(relatedData) ? relatedData.toJSON?.({ baseUrl }) : null;
         }
 
         return {
@@ -537,15 +543,17 @@ export default class OrmRequest extends Request {
         let data: unknown;
         if (info.isArray) {
           // hasMany - return array of linkage objects
-          data = ((relatedData || []) as OrmRecord[])
+          const related = Array.isArray(relatedData) ? relatedData.filter(isOrmRecord) : [];
+          data = related
             .filter((r): r is OrmRecord & { __model: { __name: string } } => Boolean(r.__model))
             .map(r => ({ type: r.__model.__name, id: r.id }));
         } else {
           // belongsTo - return single linkage or null
-          const model = relatedData ? (relatedData as OrmRecord).__model : undefined;
-          data = model
-            ? { type: model.__name, id: (relatedData as OrmRecord).id }
-            : null;
+          if (isOrmRecord(relatedData) && relatedData.__model) {
+            data = { type: relatedData.__model.__name, id: relatedData.id };
+          } else {
+            data = null;
+          }
         }
 
         return {

package/src/store.ts

@@ -30,6 +30,10 @@ interface StoreRecord {
   [key: string]: unknown;
 }
 
+function isStoreRecord(value: unknown): value is StoreRecord {
+  return typeof value === 'object' && value !== null && '__data' in value;
+}
+
 export default class Store {
   static instance: Store | undefined;
 
@@ -103,7 +107,7 @@ export default class Store {
       if (!conditions || Object.keys(conditions).length === 0) return records;
 
       return records.filter((record: unknown) =>
-        Object.entries(conditions).every(([key, value]) => (record as StoreRecord).__data[key] === value)
+        Object.entries(conditions).every(([key, value]) => isStoreRecord(record) && record.__data[key] === value)
       );
     }
 
@@ -127,7 +131,7 @@ export default class Store {
     if (!conditions || Object.keys(conditions).length === 0) return records;
 
     return records.filter((record: unknown) =>
-      Object.entries(conditions).every(([key, value]) => (record as StoreRecord).__data[key] === value)
+      Object.entries(conditions).every(([key, value]) => isStoreRecord(record) && record.__data[key] === value)
     );
   }
 
@@ -149,7 +153,7 @@ export default class Store {
     if (Object.keys(conditions).length === 0) return records;
 
     return records.filter((record: unknown) =>
-      Object.entries(conditions).every(([key, value]) => (record as StoreRecord).__data[key] === value)
+      Object.entries(conditions).every(([key, value]) => isStoreRecord(record) && record.__data[key] === value)
     );
   }
 
@@ -185,12 +189,13 @@ export default class Store {
       return;
     }
 
-    const record = modelStore.get(id as string | number) as StoreRecord | undefined;
-
-    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)
@@ -224,7 +229,10 @@ export default class Store {
       }
     }
 
-    for (const relationshipType of TYPES) (relationships.get(relationshipType) as Map<string, unknown>).delete(model);
+    for (const relationshipType of TYPES) {
+      const reg = relationships.get(relationshipType);
+      if (reg instanceof Map) reg.delete(model);
+    }
   }
 
   private _removeFromHasManyArrays(modelName: string, recordId: unknown, visited: Set<string>): void {
@@ -240,7 +248,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 as StoreRecord).id === recordId);
+        const index = hasManyArray.findIndex(r => r && isStoreRecord(r) && r.id === recordId);
         if (index !== -1) hasManyArray.splice(index, 1);
       }
     }
@@ -254,17 +262,19 @@ export default class Store {
       if (!targetModelMap) continue;
 
       for (const [sourceRecordId, belongsToRecord] of targetModelMap) {
-        if (belongsToRecord && (belongsToRecord as StoreRecord).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 as string | number) as StoreRecord | undefined;
-          if (sourceRecord && sourceRecord.__relationships) {
-            for (const [key, value] of Object.entries(sourceRecord.__relationships)) {
-              if (value && (value as StoreRecord).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;
               }
             }
           }
@@ -301,13 +311,13 @@ export default class Store {
       // hasMany children - always include
       if (Array.isArray(value)) {
         for (const childRecord of value) {
-          if (childRecord) children.push({ childRecord: childRecord as StoreRecord, relationshipKey: key, type: 'hasMany' });
+          if (childRecord && isStoreRecord(childRecord)) children.push({ childRecord, relationshipKey: key, type: 'hasMany' });
         }
-      } else if (value && !this._isBidirectionalRelationship(
+      } else if (value && isStoreRecord(value) && value.__model && !this._isBidirectionalRelationship(
         record.__model.__name,
-        (value as StoreRecord).__model.__name
+        value.__model.__name
       )) {
-        children.push({ childRecord: value as StoreRecord, relationshipKey: key, type: 'belongsTo' });
+        children.push({ childRecord: value, relationshipKey: key, type: 'belongsTo' });
       }
     }
 

package/src/utils.ts

@@ -1,9 +1,14 @@
 import { pluralize as basePluralize } from '@stonyx/utils/string';
+import type { OrmRecord } from './types/orm-types.js';
 
 export function isDbError(error: unknown): error is { code: string; message: string } {
   return typeof error === 'object' && error !== null && 'code' in error && typeof (error as Record<string, unknown>).code === 'string' && 'message' in error && typeof (error as Record<string, unknown>).message === 'string';
 }
 
+export function isOrmRecord(value: unknown): value is OrmRecord {
+  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: string): string {
   if (word.includes('-')) {