@stonyx/orm 0.3.2-beta.6 → 0.3.2-beta.60

package/dist/index.d.ts

@@ -8,6 +8,7 @@ import { createRecord, updateRecord } from './manage-record.js';
 import { count, avg, sum, min, max } from './aggregates.js';
 export { default } from './main.js';
 export { store, relationships } from './main.js';
+export type { PersistErrorDetail } from './main.js';
 export { Model, View, Serializer };
 export { attr, belongsTo, hasMany, createRecord, updateRecord };
 export { count, avg, sum, min, max };

package/dist/main.d.ts

@@ -15,6 +15,12 @@ export interface OrmDB {
     save(): Promise<void>;
     init(): Promise<void>;
 }
+export interface PersistErrorDetail {
+    operation: 'create' | 'update' | 'delete';
+    modelName: string;
+    recordId: unknown;
+    error: Error;
+}
 export default class Orm {
     static initialized: boolean;
     static relationships: Map<string, Map<string, unknown>>;
@@ -29,6 +35,7 @@ export default class Orm {
     options: OrmOptions;
     sqlDb?: SqlDb;
     db?: OrmDB | SqlDb;
+    private _persistErrorHandler;
     constructor(options?: OrmOptions);
     init(): Promise<void>;
     startup(): Promise<void>;
@@ -39,6 +46,15 @@ export default class Orm {
         serializerClass: unknown;
     };
     isView(modelName: string): boolean;
+    /**
+     * Register a callback to be invoked when a fire-and-forget SQL persist fails.
+     * Without a handler, persist errors are logged via log.error (backwards-compatible).
+     */
+    onPersistError(handler: ((detail: PersistErrorDetail) => void) | null): void;
+    /**
+     * Emit a persist error to the registered handler, or fall back to log.error.
+     */
+    emitPersistError(detail: PersistErrorDetail): void;
     warn(message: string): void;
 }
 export declare const store: Store;

package/dist/main.js

@@ -41,6 +41,7 @@ export default class Orm {
     options;
     sqlDb;
     db;
+    _persistErrorHandler = null;
     constructor(options = {}) {
         if (Orm.instance)
             return Orm.instance;
@@ -53,6 +54,10 @@ export default class Orm {
         Orm.instance = this;
     }
     async init() {
+        // Self-register so log.db works even when @stonyx/orm is in the
+        // consumer's `dependencies` (stonyx loader only merges devDependencies).
+        const { logColor = 'white', logMethod = 'db' } = config.orm;
+        log.defineType(logMethod, logColor);
         const { paths, restServer } = config.orm;
         const promises = ['Model', 'Serializer', 'Transform'].map(type => {
             const lowerCaseType = type.toLowerCase();
@@ -168,6 +173,31 @@ export default class Orm {
         const modelClassPrefix = kebabCaseToPascalCase(modelName);
         return !!this.views[`${modelClassPrefix}View`];
     }
+    /**
+     * Register a callback to be invoked when a fire-and-forget SQL persist fails.
+     * Without a handler, persist errors are logged via log.error (backwards-compatible).
+     */
+    onPersistError(handler) {
+        this._persistErrorHandler = handler;
+    }
+    /**
+     * Emit a persist error to the registered handler, or fall back to log.error.
+     */
+    emitPersistError(detail) {
+        const fallbackLog = () => log.error?.(`[ORM] Failed to persist ${detail.operation} for ${detail.modelName}:${String(detail.recordId)}: ${detail.error.message}`);
+        if (this._persistErrorHandler) {
+            try {
+                this._persistErrorHandler(detail);
+            }
+            catch (handlerError) {
+                fallbackLog();
+                log.error?.(`[ORM] onPersistError handler threw: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`);
+            }
+        }
+        else {
+            fallbackLog();
+        }
+    }
     // Queue warnings to avoid the same error from being logged in the same iteration
     warn(message) {
         this.warnings.add(message);

package/dist/manage-record.js

@@ -2,12 +2,12 @@ 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';
-import log from 'stonyx/log';
 const defaultOptions = {
     isDbRecord: false,
     serialize: true,
     transform: true
 };
+let pendingIdCounter = 0;
 export function createRecord(modelName, rawData = {}, userOptions = {}) {
     const orm = Orm.instance;
     const { initialized } = Orm;
@@ -85,7 +85,12 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
     if (shouldPersist) {
         const response = { data: { id: record.id } };
         orm.sqlDb.persist('create', modelName, { rawData }, response).catch((err) => {
-            log.error?.(`[ORM] Failed to persist create for ${modelName}:${String(record.id)}`, err);
+            orm.emitPersistError({
+                operation: 'create',
+                modelName,
+                recordId: record.id,
+                error: err instanceof Error ? err : new Error(String(err)),
+            });
         });
     }
     return record;
@@ -107,7 +112,12 @@ export function updateRecord(record, rawData, userOptions = {}) {
     const shouldPersist = orm?.sqlDb && !options.isDbRecord && !userOptions._relationshipKey && !options._skipAutoPersist;
     if (shouldPersist && modelName) {
         orm.sqlDb.persist('update', modelName, { record, oldState }, {}).catch((err) => {
-            log.error?.(`[ORM] Failed to persist update for ${modelName}:${String(record.id)}`, err);
+            orm.emitPersistError({
+                operation: 'update',
+                modelName,
+                recordId: record.id,
+                error: err instanceof Error ? err : new Error(String(err)),
+            });
         });
     }
 }
@@ -120,9 +130,11 @@ export function updateRecord(record, rawData, userOptions = {}) {
 function assignRecordId(modelName, rawData) {
     if (rawData.id)
         return;
-    // In SQL mode with numeric IDs, defer to database auto-increment
+    // In SQL mode with numeric IDs, defer to database auto-increment.
+    // Use unique negative integers — they survive the number transform (parseInt preserves negatives)
+    // and avoid NaN store-key collisions that string pending IDs caused.
     if (Orm.instance?.sqlDb && !isStringIdModel(modelName)) {
-        rawData.id = `__pending_${Date.now()}_${Math.random()}`;
+        rawData.id = -(++pendingIdCounter);
         rawData.__pendingSqlId = true;
         return;
     }

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

@@ -16,6 +16,7 @@ interface PersistContext {
     record?: OrmRecord;
     recordId?: unknown;
     oldState?: Record<string, unknown>;
+    rawData?: Record<string, unknown>;
 }
 interface PersistResponse {
     data?: {

package/dist/mysql/mysql-db.js

@@ -321,8 +321,10 @@ export default class MysqlDB {
         if (!record)
             return;
         const insertData = this._recordToRow(record, schema);
-        // For auto-increment models, remove the pending ID
-        const isPendingId = record.__data.__pendingSqlId;
+        // For auto-increment models, remove the pending ID.
+        // Check context.rawData (not record.__data) because __pendingSqlId is not a model
+        // attribute and gets lost during serialization.
+        const isPendingId = context.rawData?.__pendingSqlId === true;
         if (isPendingId) {
             delete insertData.id;
         }

package/dist/postgres/postgres-db.js

@@ -376,8 +376,10 @@ export default class PostgresDB {
         if (!record)
             return;
         const insertData = this._recordToRow(record, schema, context.rawData);
-        // For auto-increment models, remove the pending ID
-        const isPendingId = record.__data.__pendingSqlId;
+        // For auto-increment models, remove the pending ID.
+        // Check context.rawData (not record.__data) because __pendingSqlId is not a model
+        // attribute and gets lost during serialization.
+        const isPendingId = context.rawData?.__pendingSqlId === true;
         if (isPendingId) {
             delete insertData.id;
         }

package/dist/store.js

@@ -115,7 +115,12 @@ export default class Store {
         // Auto-persist delete to SQL
         if (id && Orm.instance?.sqlDb) {
             Orm.instance.sqlDb.persist('delete', key, { recordId: id }, {}).catch((err) => {
-                console.error(`[ORM] Failed to persist delete for ${key}:${id}`, err);
+                Orm.instance.emitPersistError({
+                    operation: 'delete',
+                    modelName: key,
+                    recordId: id,
+                    error: err instanceof Error ? err : new Error(String(err)),
+                });
             });
         }
         if (id)

package/dist/types/orm-types.d.ts

@@ -49,6 +49,8 @@ export interface OrmSection {
     mysql?: OrmMysqlConfig;
     postgres?: OrmPostgresConfig;
     timescale?: OrmPostgresConfig;
+    logColor?: string;
+    logMethod?: string;
     [key: string]: unknown;
 }
 export interface OrmConfig {

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.3.2-beta.6",
+  "version": "0.3.2-beta.60",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
@@ -61,9 +61,9 @@
   },
   "homepage": "https://github.com/abofs/stonyx-orm#readme",
   "dependencies": {
-    "@stonyx/cron": "0.2.1-beta.29",
-    "@stonyx/events": "0.1.1-beta.9",
-    "stonyx": "0.2.3-beta.11"
+    "@stonyx/cron": "0.2.1-beta.63",
+    "@stonyx/events": "0.1.1-beta.49",
+    "stonyx": "0.2.3-beta.64"
   },
   "peerDependencies": {
     "@stonyx/rest-server": ">=0.2.1-beta.14",
@@ -82,18 +82,19 @@
     }
   },
   "devDependencies": {
-    "@stonyx/rest-server": "0.2.1-beta.30",
-    "@stonyx/utils": "0.2.3-beta.7",
+    "@stonyx/rest-server": "0.2.1-beta.64",
+    "@stonyx/utils": "0.2.3-beta.24",
     "@types/node": "^25.6.0",
     "mysql2": "^3.20.0",
     "pg": "^8.20.0",
     "qunit": "^2.24.1",
     "sinon": "^21.0.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.8.3"
   },
   "scripts": {
     "build": "tsc",
     "build:test": "tsc -p tsconfig.test.json",
-    "test": "npm run build && npm run build:test && stonyx test 'dist-test/test/**/*-test.js'"
+    "test": "pnpm build && NODE_ENV=test node --import tsx/esm --import ./test/setup.ts node_modules/qunit/bin/qunit.js 'test/**/*-test.ts'"
   }
 }

package/src/index.ts

@@ -26,6 +26,7 @@ import { count, avg, sum, min, max } from './aggregates.js';
 
 export { default } from './main.js';
 export { store, relationships } from './main.js';
+export type { PersistErrorDetail } from './main.js';
 export { Model, View, Serializer }; // base classes
 export { attr, belongsTo, hasMany, createRecord, updateRecord }; // helpers
 export { count, avg, sum, min, max }; // aggregate helpers

package/src/main.ts

@@ -49,6 +49,13 @@ const defaultOptions: OrmOptions = {
   dbType: 'json'
 }
 
+export interface PersistErrorDetail {
+  operation: 'create' | 'update' | 'delete';
+  modelName: string;
+  recordId: unknown;
+  error: Error;
+}
+
 export default class Orm {
   static initialized: boolean = false;
   static relationships: Map<string, Map<string, unknown>> = new Map();
@@ -65,6 +72,8 @@ export default class Orm {
   sqlDb?: SqlDb;
   db?: OrmDB | SqlDb;
 
+  private _persistErrorHandler: ((detail: PersistErrorDetail) => void) | null = null;
+
   constructor(options: OrmOptions = {}) {
     if (Orm.instance) return Orm.instance;
 
@@ -81,6 +90,11 @@ export default class Orm {
   }
 
   async init(): Promise<void> {
+    // Self-register so log.db works even when @stonyx/orm is in the
+    // consumer's `dependencies` (stonyx loader only merges devDependencies).
+    const { logColor = 'white', logMethod = 'db' } = config.orm;
+    log.defineType(logMethod, logColor);
+
     const { paths, restServer } = config.orm;
 
     const promises: Promise<unknown>[] = ['Model', 'Serializer', 'Transform'].map(type => {
@@ -214,6 +228,32 @@ export default class Orm {
     return !!this.views[`${modelClassPrefix}View`];
   }
 
+  /**
+   * Register a callback to be invoked when a fire-and-forget SQL persist fails.
+   * Without a handler, persist errors are logged via log.error (backwards-compatible).
+   */
+  onPersistError(handler: ((detail: PersistErrorDetail) => void) | null): void {
+    this._persistErrorHandler = handler;
+  }
+
+  /**
+   * Emit a persist error to the registered handler, or fall back to log.error.
+   */
+  emitPersistError(detail: PersistErrorDetail): void {
+    const fallbackLog = () => log.error?.(`[ORM] Failed to persist ${detail.operation} for ${detail.modelName}:${String(detail.recordId)}: ${detail.error.message}`);
+
+    if (this._persistErrorHandler) {
+      try {
+        this._persistErrorHandler(detail);
+      } catch (handlerError) {
+        fallbackLog();
+        log.error?.(`[ORM] onPersistError handler threw: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`);
+      }
+    } else {
+      fallbackLog();
+    }
+  }
+
   // Queue warnings to avoid the same error from being logged in the same iteration
   warn(message: string): void {
     this.warnings.add(message);

package/src/manage-record.ts

@@ -3,7 +3,6 @@ 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';
-import log from 'stonyx/log';
 
 interface CreateRecordOptions {
   isDbRecord?: boolean;
@@ -27,6 +26,8 @@ const defaultOptions: CreateRecordOptions = {
   transform: true
 };
 
+let pendingIdCounter = 0;
+
 export function createRecord(modelName: string, rawData: { [key: string]: unknown } = {}, userOptions: CreateRecordOptions = {}): OrmRecord {
   const orm = Orm.instance;
   const { initialized } = Orm;
@@ -118,7 +119,12 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
   if (shouldPersist) {
     const response = { data: { id: record.id } };
     orm!.sqlDb!.persist('create', modelName, { rawData }, response).catch((err: unknown) => {
-      log.error?.(`[ORM] Failed to persist create for ${modelName}:${String(record.id)}`, err);
+      orm!.emitPersistError({
+        operation: 'create',
+        modelName,
+        recordId: record.id,
+        error: err instanceof Error ? err : new Error(String(err)),
+      });
     });
   }
 
@@ -146,7 +152,12 @@ export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: C
   const shouldPersist = orm?.sqlDb && !options.isDbRecord && !userOptions._relationshipKey && !options._skipAutoPersist;
   if (shouldPersist && modelName) {
     orm!.sqlDb!.persist('update', modelName, { record, oldState }, {}).catch((err: unknown) => {
-      log.error?.(`[ORM] Failed to persist update for ${modelName}:${String(record.id)}`, err);
+      orm!.emitPersistError({
+        operation: 'update',
+        modelName,
+        recordId: record.id,
+        error: err instanceof Error ? err : new Error(String(err)),
+      });
     });
   }
 }
@@ -160,9 +171,11 @@ export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: C
 function assignRecordId(modelName: string, rawData: { [key: string]: unknown }): void {
   if (rawData.id) return;
 
-  // In SQL mode with numeric IDs, defer to database auto-increment
+  // In SQL mode with numeric IDs, defer to database auto-increment.
+  // Use unique negative integers — they survive the number transform (parseInt preserves negatives)
+  // and avoid NaN store-key collisions that string pending IDs caused.
   if (Orm.instance?.sqlDb && !isStringIdModel(modelName)) {
-    rawData.id = `__pending_${Date.now()}_${Math.random()}`;
+    rawData.id = -(++pendingIdCounter);
     rawData.__pendingSqlId = true;
     return;
   }

package/src/mysql/mysql-db.ts

@@ -21,6 +21,7 @@ interface PersistContext {
   record?: OrmRecord;
   recordId?: unknown;
   oldState?: Record<string, unknown>;
+  rawData?: Record<string, unknown>;
 }
 
 interface PersistResponse {
@@ -420,8 +421,10 @@ export default class MysqlDB {
 
     const insertData = this._recordToRow(record, schema);
 
-    // For auto-increment models, remove the pending ID
-    const isPendingId = record.__data.__pendingSqlId;
+    // For auto-increment models, remove the pending ID.
+    // Check context.rawData (not record.__data) because __pendingSqlId is not a model
+    // attribute and gets lost during serialization.
+    const isPendingId = context.rawData?.__pendingSqlId === true;
 
     if (isPendingId) {
       delete insertData.id;

package/src/postgres/postgres-db.ts

@@ -494,8 +494,10 @@ export default class PostgresDB {
 
     const insertData = this._recordToRow(record, schema, context.rawData);
 
-    // For auto-increment models, remove the pending ID
-    const isPendingId = record.__data.__pendingSqlId;
+    // For auto-increment models, remove the pending ID.
+    // Check context.rawData (not record.__data) because __pendingSqlId is not a model
+    // attribute and gets lost during serialization.
+    const isPendingId = context.rawData?.__pendingSqlId === true;
 
     if (isPendingId) {
       delete insertData.id;

package/src/store.ts

@@ -179,7 +179,12 @@ export default class Store {
     // Auto-persist delete to SQL
     if (id && Orm.instance?.sqlDb) {
       Orm.instance.sqlDb.persist('delete', key, { recordId: id }, {}).catch((err: unknown) => {
-        console.error(`[ORM] Failed to persist delete for ${key}:${id}`, err);
+        Orm.instance.emitPersistError({
+          operation: 'delete',
+          modelName: key,
+          recordId: id,
+          error: err instanceof Error ? err : new Error(String(err)),
+        });
       });
     }
 

package/src/types/orm-types.ts

@@ -55,6 +55,8 @@ export interface OrmSection {
   mysql?: OrmMysqlConfig;
   postgres?: OrmPostgresConfig;
   timescale?: OrmPostgresConfig;
+  logColor?: string;
+  logMethod?: string;
   [key: string]: unknown;
 }
 

package/src/types/stonyx.d.ts

@@ -5,7 +5,13 @@ declare module 'stonyx/config' {
 }
 
 declare module 'stonyx/log' {
-  const log: Record<string, ((...args: unknown[]) => void) | undefined>;
+  interface Log {
+    db(message: string): void;
+    error(message: string, ...args: unknown[]): void;
+    defineType(type: string, setting: string, options?: Record<string, unknown> | null): void;
+    [key: string]: ((...args: unknown[]) => void) | undefined;
+  }
+  const log: Log;
   export default log;
 }