@stonyx/orm 0.2.1-beta.84 → 0.2.1-beta.86

package/dist/belongs-to.js

@@ -42,7 +42,8 @@ export default function belongsTo(modelName) {
         }
         relationship.set(relationshipId, output || {});
         // Populate hasMany side if the relationship is defined
-        const otherSide = hasManyRelationships.get(modelName)?.get(sourceModelName)?.get(output?.id);
+        const outputRecord = typeof output === 'object' && output !== null && 'id' in output ? output : undefined;
+        const otherSide = outputRecord ? hasManyRelationships.get(modelName)?.get(sourceModelName)?.get(outputRecord.id) : undefined;
         if (otherSide) {
             otherSide.push(sourceRecord);
             // Remove pending queue if it was just fulfilled

package/dist/has-many.js

@@ -36,8 +36,9 @@ export default function hasMany(modelName) {
                 record = createRecord(modelName, elementData, options);
             }
             // Populate belongTo side if the relationship is defined
-            const otherSide = getBelongsToRegistry()
-                .get(modelName)?.get(sourceModelName)?.get(record.id);
+            const recordWithId = typeof record === 'object' && record !== null && 'id' in record ? record : undefined;
+            const otherSide = recordWithId ? getBelongsToRegistry()
+                .get(modelName)?.get(sourceModelName)?.get(recordWithId.id) : undefined;
             if (otherSide)
                 Object.assign(otherSide, sourceRecord);
             return record;

package/dist/main.js

@@ -66,7 +66,8 @@ export default class Orm {
                     Orm.store.set(name, new Map());
                     registerPluralName(name, exported);
                 }
-                return this[pluralize(lowerCaseType)][alias] = exported;
+                const collection = this[pluralize(lowerCaseType)];
+                return collection[alias] = exported;
             }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
         });
         // Wait for imports before db & rest server setup

package/dist/manage-record.js

@@ -22,8 +22,12 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
     if (!modelStore)
         throw new Error(`Model store for '${modelName}' is not registered. Ensure the model is defined before creating records.`);
     assignRecordId(modelName, rawData);
-    if (modelStore.has(rawData.id))
-        return modelStore.get(rawData.id);
+    const existingRecord = modelStore.get(rawData.id);
+    if (existingRecord) {
+        // Update the existing record with new data so the last entry wins
+        updateRecord(existingRecord, rawData, { ...options, update: true });
+        return existingRecord;
+    }
     const recordClasses = orm.getRecordClasses(modelName);
     const modelClass = recordClasses.modelClass;
     const serializerClass = recordClasses.serializerClass;

package/dist/mysql/mysql-db.js

@@ -123,7 +123,8 @@ export default class MysqlDB {
             const schema = schemas[modelName];
             const { sql, values } = this.deps.buildSelect(schema.table);
             try {
-                const [rows] = await this.requirePool().execute(sql, values);
+                const result = await this.requirePool().execute(sql, values);
+                const rows = result[0];
                 for (const row of rows) {
                     const rawData = this._rowToRawData(row, schema);
                     this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false });
@@ -149,7 +150,8 @@ export default class MysqlDB {
             const schema = { table: viewSchema.viewName, columns: viewSchema.columns || {}, foreignKeys: viewSchema.foreignKeys || {} };
             const { sql, values } = this.deps.buildSelect(schema.table);
             try {
-                const [rows] = await this.requirePool().execute(sql, values);
+                const result = await this.requirePool().execute(sql, values);
+                const rows = result[0];
                 for (const row of rows) {
                     const rawData = this._rowToRawData(row, schema);
                     this.deps.createRecord(viewName, rawData, { isDbRecord: true, serialize: false, transform: false });
@@ -189,7 +191,8 @@ export default class MysqlDB {
             return undefined;
         const { sql, values } = this.deps.buildSelect(schema.table, { id });
         try {
-            const [rows] = await this.requirePool().execute(sql, values);
+            const result = await this.requirePool().execute(sql, values);
+            const rows = result[0];
             if (rows.length === 0)
                 return undefined;
             const rawData = this._rowToRawData(rows[0], schema);
@@ -223,7 +226,8 @@ export default class MysqlDB {
             return [];
         const { sql, values } = this.deps.buildSelect(schema.table, conditions);
         try {
-            const [rows] = await this.requirePool().execute(sql, values);
+            const result = await this.requirePool().execute(sql, values);
+            const rows = result[0];
             const records = rows.map(row => {
                 const rawData = this._rowToRawData(row, schema);
                 return this.deps.createRecord(modelName, rawData, { isDbRecord: true, serialize: false, transform: false });

package/dist/orm-request.js

@@ -99,12 +99,14 @@ function traverseIncludePath(currentRecords, includePath, depth, seen, included)
             const type = relatedRecord.__model.__name;
             const id = relatedRecord.id;
             // Initialize Set for this type if needed
-            if (!seen.has(type)) {
-                seen.set(type, new Set());
+            let seenIds = seen.get(type);
+            if (!seenIds) {
+                seenIds = new Set();
+                seen.set(type, seenIds);
             }
             // Check if we've already seen this type+id combination
-            if (!seen.get(type).has(id)) {
-                seen.get(type).add(id);
+            if (!seenIds.has(id)) {
+                seenIds.add(id);
                 included.push(relatedRecord);
                 nextRecords.push(relatedRecord); // Prepare for next depth level
             }

package/dist/postgres/postgres-db.js

@@ -150,9 +150,10 @@ export default class PostgresDB {
                 this.deps.log.db(`Skipping memory load for view '${viewName}' (memory: false)`);
                 continue;
             }
+            const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
             const schema = {
                 table: viewSchema.viewName,
-                idType: 'number',
+                idType: sourceIdType,
                 columns: viewSchema.columns || {},
                 foreignKeys: (viewSchema.foreignKeys || {}),
                 relationships: { belongsTo: {}, hasMany: {} },
@@ -194,9 +195,10 @@ export default class PostgresDB {
             const viewSchemas = this.deps.introspectViews();
             const viewSchema = viewSchemas[modelName];
             if (viewSchema) {
+                const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
                 schema = {
                     table: viewSchema.viewName,
-                    idType: 'number',
+                    idType: sourceIdType,
                     columns: viewSchema.columns || {},
                     foreignKeys: (viewSchema.foreignKeys || {}),
                     relationships: { belongsTo: {}, hasMany: {} },
@@ -234,9 +236,10 @@ export default class PostgresDB {
             const viewSchemas = this.deps.introspectViews();
             const viewSchema = viewSchemas[modelName];
             if (viewSchema) {
+                const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
                 schema = {
                     table: viewSchema.viewName,
-                    idType: 'number',
+                    idType: sourceIdType,
                     columns: viewSchema.columns || {},
                     foreignKeys: (viewSchema.foreignKeys || {}),
                     relationships: { belongsTo: {}, hasMany: {} },

package/dist/record.js

@@ -39,9 +39,23 @@ export default class Record {
         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;
+            if (Array.isArray(childRecord)) {
+                // Deduplicate by record ID — keep last occurrence (latest data wins)
+                const seen = new Set();
+                const unique = [];
+                for (let i = childRecord.length - 1; i >= 0; i--) {
+                    const r = childRecord[i];
+                    if (!seen.has(r.id)) {
+                        seen.add(r.id);
+                        unique.push(r);
+                    }
+                }
+                unique.reverse();
+                records[key] = unique.map((r) => r.serialize());
+            }
+            else {
+                records[key] = childRecord?.serialize() ?? null;
+            }
         }
         return { ...data, ...records };
     }

package/dist/relationships.js

@@ -1,7 +1,11 @@
 import { relationships } from '@stonyx/orm';
 // TODO: Refactor mapping to remove a level of iteration
 export function getRelationships(type, sourceModel, targetModel, relationshipId) {
-    const allRelationships = relationships.get(type);
+    let allRelationships = relationships.get(type);
+    if (!allRelationships) {
+        allRelationships = new Map();
+        relationships.set(type, allRelationships);
+    }
     // create relationship map for this type of it doesn't already exist
     if (!allRelationships.has(sourceModel))
         allRelationships.set(sourceModel, new Map());

package/dist/serializer.js

@@ -1,6 +1,12 @@
 import config from 'stonyx/config';
 import { get, makeArray } from '@stonyx/utils/object';
 const RESERVED_KEYS = ['__name'];
+function isAggregateProperty(v) {
+    return typeof v === 'object' && v !== null && v.__kind === 'AggregateProperty';
+}
+function isModelProperty(v) {
+    return typeof v === 'object' && v !== null && v.__kind === 'ModelProperty';
+}
 function searchQuery(query, array, key) {
     const result = makeArray(array).find((item) => {
         for (const [prop, value] of Object.entries(query)) {
@@ -78,13 +84,13 @@ export default class Serializer {
                 continue;
             }
             // Aggregate property handling — use the rawData value, not the aggregate descriptor
-            if (handler?.__kind === 'AggregateProperty') {
+            if (isAggregateProperty(handler)) {
                 parsedData[key] = data;
                 rec[key] = data;
                 continue;
             }
             // Direct assignment handling
-            if (handler?.__kind !== 'ModelProperty') {
+            if (!isModelProperty(handler)) {
                 parsedData[key] = handler;
                 rec[key] = handler;
                 continue;

package/dist/store.js

@@ -133,7 +133,7 @@ export default class Store {
             this._nullifyBelongsToReferences(modelName, recordId, visited);
             this._cleanupRelationshipRegistries(modelName, recordId);
             recordToUnload.clean();
-            this.data.get(modelName).delete(recordId);
+            this.data.get(modelName)?.delete(recordId);
         }
     }
     unloadAllRecords(model, options = {}) {

package/dist/timescale/timescale-db.d.ts

@@ -19,6 +19,7 @@ export default class TimescaleDB extends PostgresDB {
     static extensions: string[];
     static configKey: string;
     constructor(deps?: Record<string, unknown>);
+    private get tsDeps();
     /**
      * Convert a table to a TimescaleDB hypertable.
      * Should be called after the table is created (e.g. after initial migration).

package/dist/timescale/timescale-db.js

@@ -14,6 +14,9 @@ export default class TimescaleDB extends PostgresDB {
             buildEnableCompression,
         });
     }
+    get tsDeps() {
+        return this.deps;
+    }
     /**
      * Convert a table to a TimescaleDB hypertable.
      * Should be called after the table is created (e.g. after initial migration).
@@ -23,7 +26,7 @@ export default class TimescaleDB extends PostgresDB {
         const schema = schemas[modelName];
         if (!schema)
             throw new Error(`Model '${modelName}' not found`);
-        const { sql } = this.deps.buildCreateHypertable(schema.table, timeColumn, options);
+        const { sql } = this.tsDeps.buildCreateHypertable(schema.table, timeColumn, options);
         await this.requirePool().query(sql);
     }
     /**
@@ -34,7 +37,7 @@ export default class TimescaleDB extends PostgresDB {
         const schema = schemas[modelName];
         if (!schema)
             return [];
-        const { sql, values } = this.deps.buildTimeBucket(schema.table, timeColumn, bucketSize, options);
+        const { sql, values } = this.tsDeps.buildTimeBucket(schema.table, timeColumn, bucketSize, options);
         try {
             const result = await this.requirePool().query(sql, values);
             return result.rows;
@@ -53,7 +56,7 @@ export default class TimescaleDB extends PostgresDB {
         const schema = schemas[modelName];
         if (!schema)
             throw new Error(`Model '${modelName}' not found`);
-        const { sql } = this.deps.buildContinuousAggregate(viewName, schema.table, timeColumn, bucketSize, aggregates, options);
+        const { sql } = this.tsDeps.buildContinuousAggregate(viewName, schema.table, timeColumn, bucketSize, aggregates, options);
         await this.requirePool().query(sql);
     }
     /**
@@ -64,7 +67,7 @@ export default class TimescaleDB extends PostgresDB {
         const schema = schemas[modelName];
         if (!schema)
             throw new Error(`Model '${modelName}' not found`);
-        const { sql } = this.deps.buildEnableCompression(schema.table, options.segmentBy, options.orderBy);
+        const { sql } = this.tsDeps.buildEnableCompression(schema.table, options.segmentBy, options.orderBy);
         await this.requirePool().query(sql);
     }
     /**
@@ -75,7 +78,7 @@ export default class TimescaleDB extends PostgresDB {
         const schema = schemas[modelName];
         if (!schema)
             throw new Error(`Model '${modelName}' not found`);
-        const { sql } = this.deps.buildCompressionPolicy(schema.table, compressAfter);
+        const { sql } = this.tsDeps.buildCompressionPolicy(schema.table, compressAfter);
         await this.requirePool().query(sql);
     }
 }

package/dist/view-resolver.js

@@ -49,6 +49,8 @@ export default class ViewResolver {
             const rawData = { id: sourceRecord.id };
             // Compute aggregate fields from source record's relationships
             for (const [key, aggProp] of Object.entries(aggregateFields)) {
+                if (!aggProp.relationship)
+                    continue;
                 const relatedRecords = sourceRecord.__relationships?.[aggProp.relationship]
                     || sourceRecord[aggProp.relationship];
                 const relArray = Array.isArray(relatedRecords) ? relatedRecords : [];
@@ -112,6 +114,8 @@ export default class ViewResolver {
                 }
                 else {
                     // Relationship aggregate — flatten related records across all group members
+                    if (!aggProp.relationship)
+                        continue;
                     const allRelated = [];
                     for (const record of groupRecords) {
                         const relatedRecords = record.__relationships?.[aggProp.relationship]

package/package.json

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

package/src/belongs-to.ts

@@ -69,7 +69,8 @@ export default function belongsTo(modelName: string): RelationshipHandler {
     relationship.set(relationshipId, output || {});
 
     // Populate hasMany side if the relationship is defined
-    const otherSide = hasManyRelationships.get(modelName)?.get(sourceModelName)?.get((output as SourceRecord)?.id) as unknown[] | undefined;
+    const outputRecord = typeof output === 'object' && output !== null && 'id' in output ? output as SourceRecord : undefined;
+    const otherSide = outputRecord ? hasManyRelationships.get(modelName)?.get(sourceModelName)?.get(outputRecord.id) as unknown[] | undefined : undefined;
 
     if (otherSide) {
       otherSide.push(sourceRecord);

package/src/has-many.ts

@@ -44,7 +44,7 @@ export default function hasMany(modelName: string): RelationshipHandler {
     const modelStore = store.get(modelName);
     const pendingRelationshipQueue: PendingItem[] = [];
 
-    const output: unknown[] = !rawData ? [] : (makeArray(rawData) as unknown[]).map((elementData: unknown) => {
+    const output: unknown[] = !rawData ? [] : makeArray(rawData).map((elementData: unknown) => {
       let record: unknown;
 
       if (typeof elementData !== 'object') {
@@ -66,8 +66,9 @@ export default function hasMany(modelName: string): RelationshipHandler {
       }
 
       // Populate belongTo side if the relationship is defined
-      const otherSide = getBelongsToRegistry()
-        .get(modelName)?.get(sourceModelName)?.get((record as SourceRecord).id);
+      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);
 

package/src/main.ts

@@ -98,7 +98,8 @@ export default class Orm {
           registerPluralName(name, exported as { pluralName?: string });
         }
 
-        return (this as unknown as Record<string, Record<string, unknown>>)[pluralize(lowerCaseType)][alias] = exported;
+        const collection = this[pluralize(lowerCaseType) as keyof this] as Record<string, unknown>;
+        return collection[alias] = exported;
       }, { ignoreAccessFailure: true, rawName: true, recursive: true, recursiveNaming: true });
     });
 

package/src/manage-record.ts

@@ -43,7 +43,13 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
   if (!modelStore) throw new Error(`Model store for '${modelName}' is not registered. Ensure the model is defined before creating records.`);
 
   assignRecordId(modelName, rawData);
-  if (modelStore.has(rawData.id as number | string)) return modelStore.get(rawData.id as number | string)! as OrmRecord;
+  const existingRecord = modelStore.get(rawData.id as number | string);
+
+  if (existingRecord) {
+    // Update the existing record with new data so the last entry wins
+    updateRecord(existingRecord as OrmRecord, rawData, { ...options, update: true });
+    return existingRecord as OrmRecord;
+  }
 
   const recordClasses = orm.getRecordClasses(modelName);
   const modelClass = recordClasses.modelClass as (new (name: string) => { __name: string; [key: string]: unknown }) | undefined;

package/src/mysql/mysql-db.ts

@@ -72,7 +72,7 @@ const defaultDeps: MysqlDBDeps = {
   introspectModels, introspectViews, getTopologicalOrder, schemasToSnapshot,
   loadLatestSnapshot, detectSchemaDrift,
   buildInsert, buildUpdate, buildDelete, buildSelect,
-  createRecord, store: store as unknown as OrmStore, confirm, readFile, getPluralName,
+  createRecord, store: store as OrmStore, confirm, readFile, getPluralName,
   config, log, path
 };
 
@@ -199,7 +199,8 @@ export default class MysqlDB {
       const { sql, values } = this.deps.buildSelect(schema.table);
 
       try {
-        const [rows] = await this.requirePool().execute(sql, values) as [Record<string, unknown>[], unknown];
+        const result = await this.requirePool().execute(sql, values);
+        const rows = result[0] as Record<string, unknown>[];
 
         for (const row of rows) {
           const rawData = this._rowToRawData(row, schema);
@@ -230,7 +231,8 @@ export default class MysqlDB {
       const { sql, values } = this.deps.buildSelect(schema.table);
 
       try {
-        const [rows] = await this.requirePool().execute(sql, values) as [Record<string, unknown>[], unknown];
+        const result = await this.requirePool().execute(sql, values);
+        const rows = result[0] as Record<string, unknown>[];
 
         for (const row of rows) {
           const rawData = this._rowToRawData(row, schema);
@@ -275,7 +277,8 @@ export default class MysqlDB {
     const { sql, values } = this.deps.buildSelect(schema.table, { id });
 
     try {
-      const [rows] = await this.requirePool().execute(sql, values) as [Record<string, unknown>[], unknown];
+      const result = await this.requirePool().execute(sql, values);
+      const rows = result[0] as Record<string, unknown>[];
 
       if (rows.length === 0) return undefined;
 
@@ -314,7 +317,8 @@ export default class MysqlDB {
     const { sql, values } = this.deps.buildSelect(schema.table, conditions);
 
     try {
-      const [rows] = await this.requirePool().execute(sql, values) as [Record<string, unknown>[], unknown];
+      const result = await this.requirePool().execute(sql, values);
+      const rows = result[0] as Record<string, unknown>[];
 
       const records = rows.map(row => {
         const rawData = this._rowToRawData(row, schema!);

package/src/orm-request.ts

@@ -167,13 +167,15 @@ function traverseIncludePath(
       const id = relatedRecord.id as string | number;
 
       // Initialize Set for this type if needed
-      if (!seen.has(type)) {
-        seen.set(type, new Set());
+      let seenIds = seen.get(type);
+      if (!seenIds) {
+        seenIds = new Set();
+        seen.set(type, seenIds);
       }
 
       // Check if we've already seen this type+id combination
-      if (!seen.get(type)!.has(id)) {
-        seen.get(type)!.add(id);
+      if (!seenIds.has(id)) {
+        seenIds.add(id);
         included.push(relatedRecord);
         nextRecords.push(relatedRecord); // Prepare for next depth level
       } else if (depth < includePath.length - 1) {

package/src/postgres/postgres-db.ts

@@ -235,9 +235,10 @@ export default class PostgresDB {
         continue;
       }
 
+      const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
       const schema: ModelSchema = {
         table: viewSchema.viewName,
-        idType: 'number',
+        idType: sourceIdType,
         columns: viewSchema.columns || {},
         foreignKeys: (viewSchema.foreignKeys || {}) as Record<string, ForeignKeyDef>,
         relationships: { belongsTo: {}, hasMany: {} },
@@ -283,9 +284,10 @@ export default class PostgresDB {
       const viewSchemas = this.deps.introspectViews();
       const viewSchema = viewSchemas[modelName];
       if (viewSchema) {
+        const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
         schema = {
           table: viewSchema.viewName,
-          idType: 'number',
+          idType: sourceIdType,
           columns: viewSchema.columns || {},
           foreignKeys: (viewSchema.foreignKeys || {}) as Record<string, ForeignKeyDef>,
           relationships: { belongsTo: {}, hasMany: {} },
@@ -328,9 +330,10 @@ export default class PostgresDB {
       const viewSchemas = this.deps.introspectViews();
       const viewSchema = viewSchemas[modelName];
       if (viewSchema) {
+        const sourceIdType = schemas[viewSchema.source]?.idType || 'number';
         schema = {
           table: viewSchema.viewName,
-          idType: 'number',
+          idType: sourceIdType,
           columns: viewSchema.columns || {},
           foreignKeys: (viewSchema.foreignKeys || {}) as Record<string, ForeignKeyDef>,
           relationships: { belongsTo: {}, hasMany: {} },
@@ -423,7 +426,7 @@ export default class PostgresDB {
    * @private
    */
   private _evictIfNotMemory(modelName: string, record: OrmRecord): void {
-    const storeRef = this.deps.store as unknown as {
+    const storeRef = this.deps.store as {
       _memoryResolver?: (name: string) => boolean;
       get?: (name: string) => Map<unknown, unknown> | undefined;
       data?: { get(name: string): Map<unknown, unknown> | undefined };

package/src/record.ts

@@ -86,9 +86,24 @@ export default class Record {
     const records: { [key: string]: unknown } = {};
 
     for (const [key, childRecord] of Object.entries(this.__relationships)) {
-      records[key] = Array.isArray(childRecord)
-        ? childRecord.map((r: Record) => r.serialize())
-        : (childRecord as Record)?.serialize() ?? null;
+      if (Array.isArray(childRecord)) {
+        // Deduplicate by record ID — keep last occurrence (latest data wins)
+        const seen = new Set<unknown>();
+        const unique: Record[] = [];
+
+        for (let i = childRecord.length - 1; i >= 0; i--) {
+          const r = childRecord[i] as Record;
+          if (!seen.has(r.id)) {
+            seen.add(r.id);
+            unique.push(r);
+          }
+        }
+
+        unique.reverse();
+        records[key] = unique.map((r: Record) => r.serialize());
+      } else {
+        records[key] = (childRecord as Record)?.serialize() ?? null;
+      }
     }
 
     return { ...data, ...records };

package/src/relationships.ts

@@ -3,12 +3,17 @@ import type { HasManyMap, BelongsToMap, GlobalMap, PendingMap, PendingBelongsToM
 
 // TODO: Refactor mapping to remove a level of iteration
 export function getRelationships(type: string, sourceModel: string, targetModel: string, relationshipId?: string): Map<unknown, unknown> | undefined {
-  const allRelationships = relationships.get(type) as Map<string, Map<string, Map<unknown, unknown>>> | undefined;
+  let allRelationships = relationships.get(type) as Map<string, Map<string, Map<unknown, unknown>>> | undefined;
+
+  if (!allRelationships) {
+    allRelationships = new Map();
+    relationships.set(type, allRelationships);
+  }
 
   // create relationship map for this type of it doesn't already exist
-  if (!allRelationships!.has(sourceModel)) allRelationships!.set(sourceModel, new Map());
+  if (!allRelationships.has(sourceModel)) allRelationships.set(sourceModel, new Map());
 
-  const modelRelationship = allRelationships!.get(sourceModel)!;
+  const modelRelationship = allRelationships.get(sourceModel)!;
 
   if (!modelRelationship.has(targetModel)) modelRelationship.set(targetModel, new Map());
 

package/src/serializer.ts

@@ -5,6 +5,14 @@ import type ModelProperty from './model-property.js';
 
 const RESERVED_KEYS = ['__name'];
 
+function isAggregateProperty(v: unknown): v is AggregateProperty {
+  return typeof v === 'object' && v !== null && (v as { __kind?: string }).__kind === 'AggregateProperty';
+}
+
+function isModelProperty(v: unknown): v is ModelProperty {
+  return typeof v === 'object' && v !== null && (v as { __kind?: string }).__kind === 'ModelProperty';
+}
+
 function searchQuery(query: Record<string, unknown>, array: unknown, key?: string): unknown {
   const result = makeArray(array).find((item: unknown) => {
     for (const [prop, value] of Object.entries(query)) {
@@ -93,14 +101,14 @@ export default class Serializer {
       }
 
       // Aggregate property handling — use the rawData value, not the aggregate descriptor
-      if ((handler as AggregateProperty)?.__kind === 'AggregateProperty') {
+      if (isAggregateProperty(handler)) {
         parsedData[key] = data;
         rec[key] = data;
         continue;
       }
 
       // Direct assignment handling
-      if ((handler as ModelProperty)?.__kind !== 'ModelProperty') {
+      if (!isModelProperty(handler)) {
         parsedData[key] = handler;
         rec[key] = handler;
         continue;

package/src/store.ts

@@ -204,7 +204,7 @@ export default class Store {
       this._cleanupRelationshipRegistries(modelName, recordId);
       recordToUnload.clean();
 
-      this.data.get(modelName)!.delete(recordId as string | number);
+      this.data.get(modelName)?.delete(recordId as string | number);
     }
   }
 

package/src/timescale/timescale-db.ts

@@ -22,6 +22,14 @@ interface CompressionOptions {
   orderBy?: string;
 }
 
+interface TimescaleDeps {
+  buildCreateHypertable: typeof buildCreateHypertable;
+  buildTimeBucket: typeof buildTimeBucket;
+  buildContinuousAggregate: typeof buildContinuousAggregate;
+  buildEnableCompression: typeof buildEnableCompression;
+  buildCompressionPolicy: typeof buildCompressionPolicy;
+}
+
 export default class TimescaleDB extends PostgresDB {
   static override extensions: string[] = ['timescaledb'];
   static override configKey: string = 'timescale';
@@ -37,6 +45,10 @@ export default class TimescaleDB extends PostgresDB {
     });
   }
 
+  private get tsDeps(): TimescaleDeps {
+    return this.deps as unknown as TimescaleDeps;
+  }
+
   /**
    * Convert a table to a TimescaleDB hypertable.
    * Should be called after the table is created (e.g. after initial migration).
@@ -46,7 +58,7 @@ export default class TimescaleDB extends PostgresDB {
     const schema = schemas[modelName];
     if (!schema) throw new Error(`Model '${modelName}' not found`);
 
-    const { sql } = (this.deps as unknown as { buildCreateHypertable: typeof buildCreateHypertable }).buildCreateHypertable(schema.table, timeColumn, options);
+    const { sql } = this.tsDeps.buildCreateHypertable(schema.table, timeColumn, options);
     await this.requirePool().query(sql);
   }
 
@@ -58,7 +70,7 @@ export default class TimescaleDB extends PostgresDB {
     const schema = schemas[modelName];
     if (!schema) return [];
 
-    const { sql, values } = (this.deps as unknown as { buildTimeBucket: typeof buildTimeBucket }).buildTimeBucket(schema.table, timeColumn, bucketSize, options);
+    const { sql, values } = this.tsDeps.buildTimeBucket(schema.table, timeColumn, bucketSize, options);
 
     try {
       const result = await this.requirePool().query(sql, values);
@@ -77,7 +89,7 @@ export default class TimescaleDB extends PostgresDB {
     const schema = schemas[modelName];
     if (!schema) throw new Error(`Model '${modelName}' not found`);
 
-    const { sql } = (this.deps as unknown as { buildContinuousAggregate: typeof buildContinuousAggregate }).buildContinuousAggregate(viewName, schema.table, timeColumn, bucketSize, aggregates, options);
+    const { sql } = this.tsDeps.buildContinuousAggregate(viewName, schema.table, timeColumn, bucketSize, aggregates, options);
     await this.requirePool().query(sql);
   }
 
@@ -89,7 +101,7 @@ export default class TimescaleDB extends PostgresDB {
     const schema = schemas[modelName];
     if (!schema) throw new Error(`Model '${modelName}' not found`);
 
-    const { sql } = (this.deps as unknown as { buildEnableCompression: typeof buildEnableCompression }).buildEnableCompression(schema.table, options.segmentBy, options.orderBy);
+    const { sql } = this.tsDeps.buildEnableCompression(schema.table, options.segmentBy, options.orderBy);
     await this.requirePool().query(sql);
   }
 
@@ -101,7 +113,7 @@ export default class TimescaleDB extends PostgresDB {
     const schema = schemas[modelName];
     if (!schema) throw new Error(`Model '${modelName}' not found`);
 
-    const { sql } = (this.deps as unknown as { buildCompressionPolicy: typeof buildCompressionPolicy }).buildCompressionPolicy(schema.table, compressAfter);
+    const { sql } = this.tsDeps.buildCompressionPolicy(schema.table, compressAfter);
     await this.requirePool().query(sql);
   }
 }

package/src/view-resolver.ts

@@ -73,8 +73,9 @@ export default class ViewResolver {
 
       // Compute aggregate fields from source record's relationships
       for (const [key, aggProp] of Object.entries(aggregateFields)) {
-        const relatedRecords = sourceRecord.__relationships?.[aggProp.relationship!]
-          || sourceRecord[aggProp.relationship!];
+        if (!aggProp.relationship) continue;
+        const relatedRecords = sourceRecord.__relationships?.[aggProp.relationship]
+          || sourceRecord[aggProp.relationship];
         const relArray = Array.isArray(relatedRecords) ? relatedRecords : [];
         rawData[key] = aggProp.compute(relArray);
       }
@@ -151,10 +152,11 @@ export default class ViewResolver {
           rawData[key] = aggProp.compute(groupRecords);
         } else {
           // Relationship aggregate — flatten related records across all group members
+          if (!aggProp.relationship) continue;
           const allRelated: unknown[] = [];
           for (const record of groupRecords) {
-            const relatedRecords = record.__relationships?.[aggProp.relationship!]
-              || record[aggProp.relationship!];
+            const relatedRecords = record.__relationships?.[aggProp.relationship]
+              || record[aggProp.relationship];
             if (Array.isArray(relatedRecords)) {
               allRelated.push(...relatedRecords);
             }