@stonyx/orm 0.3.2-beta.5 → 0.3.2-beta.7

package/dist/index.js

@@ -33,7 +33,7 @@ export { beforeHook, afterHook, clearHook, clearAllHooks } from './hooks.js'; //
 // store.findAll(model)   -- async, all records
 // store.query(model, conditions) -- async, always hits SQL
 //
-// Programmatic CRUD (memory + SQL persistence):
-// Orm.create(model, data)      -- async, createRecord + sqlDb.persist
-// Orm.update(model, id, data)  -- async, updateRecord + sqlDb.persist
-// Orm.remove(model, id)        -- async, sqlDb.persist + store.remove
+// Data-layer auto-persist (memory + SQL persistence):
+// createRecord(model, data)  -- sync, auto-persists to SQL (fire-and-forget)
+// updateRecord(record, data) -- sync, auto-persists to SQL (fire-and-forget)
+// store.remove(model, id)    -- sync, auto-persists delete to SQL (fire-and-forget)

package/dist/main.d.ts

@@ -1,5 +1,4 @@
 import Store from './store.js';
-import type { OrmRecord } from './types/orm-types.js';
 interface OrmOptions {
     dbType?: string;
 }
@@ -40,21 +39,6 @@ export default class Orm {
         serializerClass: unknown;
     };
     isView(modelName: string): boolean;
-    /**
-     * Programmatic create — writes to memory AND persists to SQL database.
-     * Use instead of createRecord() when records must be persisted to PostgreSQL/TimescaleDB.
-     */
-    static create(modelName: string, data?: Record<string, unknown>): Promise<OrmRecord>;
-    /**
-     * Programmatic update — updates in memory AND persists to SQL database.
-     * Captures old state for diff-based UPDATE queries.
-     */
-    static update(modelName: string, id: string | number, data: Record<string, unknown>): Promise<OrmRecord>;
-    /**
-     * Programmatic delete — removes from SQL database AND memory store.
-     * SQL delete runs first to ensure consistency on failure.
-     */
-    static remove(modelName: string, id: string | number): Promise<void>;
     warn(message: string): void;
 }
 export declare const store: Store;

package/dist/main.js

@@ -24,7 +24,6 @@ import baseTransforms from './transforms.js';
 import Store from './store.js';
 import Serializer from './serializer.js';
 import { setup } from '@stonyx/events';
-import { isOrmRecord } from './utils.js';
 const defaultOptions = {
     dbType: 'json'
 };
@@ -169,55 +168,6 @@ export default class Orm {
         const modelClassPrefix = kebabCaseToPascalCase(modelName);
         return !!this.views[`${modelClassPrefix}View`];
     }
-    /**
-     * Programmatic create — writes to memory AND persists to SQL database.
-     * Use instead of createRecord() when records must be persisted to PostgreSQL/TimescaleDB.
-     */
-    static async create(modelName, data = {}) {
-        if (!Orm.initialized)
-            throw new Error('ORM is not ready');
-        const { createRecord } = await import('./manage-record.js');
-        const record = createRecord(modelName, data, { serialize: false });
-        if (Orm.instance.sqlDb) {
-            const response = { data: { id: record.id } };
-            await Orm.instance.sqlDb.persist('create', modelName, { rawData: data }, response);
-        }
-        return record;
-    }
-    /**
-     * Programmatic update — updates in memory AND persists to SQL database.
-     * Captures old state for diff-based UPDATE queries.
-     */
-    static async update(modelName, id, data) {
-        if (!Orm.initialized)
-            throw new Error('ORM is not ready');
-        const record = Orm.store.get(modelName, id);
-        if (!record || !isOrmRecord(record))
-            throw new Error(`Record ${modelName}:${id} not found`);
-        const oldState = JSON.parse(JSON.stringify(record.__data));
-        // Apply attribute updates directly, matching the REST handler pattern
-        for (const [key, value] of Object.entries(data)) {
-            if (key === 'id')
-                continue;
-            record[key] = value;
-        }
-        if (Orm.instance.sqlDb) {
-            await Orm.instance.sqlDb.persist('update', modelName, { record, oldState }, {});
-        }
-        return record;
-    }
-    /**
-     * Programmatic delete — removes from SQL database AND memory store.
-     * SQL delete runs first to ensure consistency on failure.
-     */
-    static async remove(modelName, id) {
-        if (!Orm.initialized)
-            throw new Error('ORM is not ready');
-        if (Orm.instance.sqlDb) {
-            await Orm.instance.sqlDb.persist('delete', modelName, { recordId: id }, {});
-        }
-        Orm.store.remove(modelName, id);
-    }
     // Queue warnings to avoid the same error from being logged in the same iteration
     warn(message) {
         this.warnings.add(message);

package/dist/manage-record.d.ts

@@ -4,6 +4,7 @@ interface CreateRecordOptions {
     serialize?: boolean;
     transform?: boolean;
     update?: boolean;
+    _skipAutoPersist?: boolean;
     [key: string]: unknown;
 }
 export declare function createRecord(modelName: string, rawData?: {

package/dist/manage-record.js

@@ -2,11 +2,13 @@ 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;
@@ -79,6 +81,14 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
         // Clear the pending queue
         pendingBelongsTo.length = 0;
     }
+    // Auto-persist to SQL — skip for DB loads (isDbRecord) and relationship resolution (_relationshipKey)
+    const shouldPersist = orm?.sqlDb && !options.isDbRecord && !userOptions._relationshipKey && !options._skipAutoPersist;
+    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 instanceof Error ? err.message : String(err)}`);
+        });
+    }
     return record;
 }
 export function updateRecord(record, rawData, userOptions = {}) {
@@ -90,7 +100,17 @@ export function updateRecord(record, rawData, userOptions = {}) {
         throw new Error(`Cannot update records for read-only view '${modelName}'`);
     }
     const options = { ...defaultOptions, ...userOptions, update: true };
+    // Capture old state before update for SQL diff
+    const oldState = record.__data ? JSON.parse(JSON.stringify(record.__data)) : {};
     record.serialize(rawData, options);
+    // Auto-persist to SQL — skip for DB loads (isDbRecord) and relationship resolution (_relationshipKey)
+    const orm = Orm.instance;
+    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 instanceof Error ? err.message : String(err)}`);
+        });
+    }
 }
 /**
  * gets the next available id based on last record entry.
@@ -101,9 +121,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/orm-request.js

@@ -248,7 +248,7 @@ export default class OrmRequest extends Request {
                 }
             }
             const recordAttributes = id !== undefined ? { id, ...sanitizedAttributes } : sanitizedAttributes;
-            const created = createRecord(model, recordAttributes, { serialize: false });
+            const created = createRecord(model, recordAttributes, { serialize: false, _skipAutoPersist: true });
             const record = isOrmRecord(created) ? created : null;
             if (!record)
                 return 500;
@@ -283,7 +283,7 @@ export default class OrmRequest extends Request {
                     }
                 }
                 if (Object.keys(relUpdates).length > 0) {
-                    updateRecord(record, relUpdates);
+                    updateRecord(record, relUpdates, { _skipAutoPersist: true });
                 }
             }
             return { data: record.toJSON?.() };
@@ -348,9 +348,9 @@ export default class OrmRequest extends Request {
             }
             // Execute main handler
             const response = await handler(request, state);
-            // Persist to SQL database for write operations
+            // Persist to SQL database for create/update (delete is handled by store.remove auto-persist)
             const sqlDb = Orm.instance.sqlDb;
-            if (sqlDb && WRITE_OPERATIONS.has(operation)) {
+            if (sqlDb && (operation === 'create' || operation === 'update')) {
                 await sqlDb.persist(operation, this.model, context, response);
             }
             // Add response and relevant records to context

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

@@ -112,6 +112,12 @@ export default class Store {
         if (Orm.instance?.isView?.(key)) {
             throw new Error(`Cannot remove records from read-only view '${key}'`);
         }
+        // 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 instanceof Error ? err.message : String(err)}`);
+            });
+        }
         if (id)
             return this.unloadRecord(key, id);
         this.unloadAllRecords(key);

package/package.json

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

package/src/index.ts

@@ -37,7 +37,7 @@ export { beforeHook, afterHook, clearHook, clearAllHooks } from './hooks.js'; //
 // store.findAll(model)   -- async, all records
 // store.query(model, conditions) -- async, always hits SQL
 //
-// Programmatic CRUD (memory + SQL persistence):
-// Orm.create(model, data)      -- async, createRecord + sqlDb.persist
-// Orm.update(model, id, data)  -- async, updateRecord + sqlDb.persist
-// Orm.remove(model, id)        -- async, sqlDb.persist + store.remove
+// Data-layer auto-persist (memory + SQL persistence):
+// createRecord(model, data)  -- sync, auto-persists to SQL (fire-and-forget)
+// updateRecord(record, data) -- sync, auto-persists to SQL (fire-and-forget)
+// store.remove(model, id)    -- sync, auto-persists delete to SQL (fire-and-forget)

package/src/main.ts

@@ -25,8 +25,6 @@ import baseTransforms from './transforms.js';
 import Store from './store.js';
 import Serializer from './serializer.js';
 import { setup } from '@stonyx/events';
-import type { OrmRecord } from './types/orm-types.js';
-import { isOrmRecord } from './utils.js';
 
 interface OrmOptions {
   dbType?: string;
@@ -216,63 +214,6 @@ export default class Orm {
     return !!this.views[`${modelClassPrefix}View`];
   }
 
-  /**
-   * Programmatic create — writes to memory AND persists to SQL database.
-   * Use instead of createRecord() when records must be persisted to PostgreSQL/TimescaleDB.
-   */
-  static async create(modelName: string, data: Record<string, unknown> = {}): Promise<OrmRecord> {
-    if (!Orm.initialized) throw new Error('ORM is not ready');
-
-    const { createRecord } = await import('./manage-record.js');
-    const record = createRecord(modelName, data, { serialize: false }) as unknown as OrmRecord;
-
-    if (Orm.instance.sqlDb) {
-      const response: { data: { id: unknown } } = { data: { id: record.id } };
-      await Orm.instance.sqlDb.persist('create', modelName, { rawData: data }, response);
-    }
-
-    return record;
-  }
-
-  /**
-   * Programmatic update — updates in memory AND persists to SQL database.
-   * Captures old state for diff-based UPDATE queries.
-   */
-  static async update(modelName: string, id: string | number, data: Record<string, unknown>): Promise<OrmRecord> {
-    if (!Orm.initialized) throw new Error('ORM is not ready');
-
-    const record = Orm.store.get(modelName, id);
-    if (!record || !isOrmRecord(record)) throw new Error(`Record ${modelName}:${id} not found`);
-
-    const oldState = JSON.parse(JSON.stringify(record.__data));
-
-    // Apply attribute updates directly, matching the REST handler pattern
-    for (const [key, value] of Object.entries(data)) {
-      if (key === 'id') continue;
-      record[key] = value;
-    }
-
-    if (Orm.instance.sqlDb) {
-      await Orm.instance.sqlDb.persist('update', modelName, { record, oldState }, {});
-    }
-
-    return record;
-  }
-
-  /**
-   * Programmatic delete — removes from SQL database AND memory store.
-   * SQL delete runs first to ensure consistency on failure.
-   */
-  static async remove(modelName: string, id: string | number): Promise<void> {
-    if (!Orm.initialized) throw new Error('ORM is not ready');
-
-    if (Orm.instance.sqlDb) {
-      await Orm.instance.sqlDb.persist('delete', modelName, { recordId: id }, {});
-    }
-
-    Orm.store.remove(modelName, id);
-  }
-
   // 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,12 +3,14 @@ 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;
   serialize?: boolean;
   transform?: boolean;
   update?: boolean;
+  _skipAutoPersist?: boolean;
   [key: string]: unknown;
 }
 
@@ -25,6 +27,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;
@@ -111,6 +115,15 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
     pendingBelongsTo.length = 0;
   }
 
+  // Auto-persist to SQL — skip for DB loads (isDbRecord) and relationship resolution (_relationshipKey)
+  const shouldPersist = orm?.sqlDb && !options.isDbRecord && !userOptions._relationshipKey && !options._skipAutoPersist;
+  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 instanceof Error ? err.message : String(err)}`);
+    });
+  }
+
   return record;
 }
 
@@ -125,7 +138,19 @@ export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: C
 
   const options = { ...defaultOptions, ...userOptions, update: true };
 
+  // Capture old state before update for SQL diff
+  const oldState = record.__data ? JSON.parse(JSON.stringify(record.__data)) : {};
+
   record.serialize(rawData, options);
+
+  // Auto-persist to SQL — skip for DB loads (isDbRecord) and relationship resolution (_relationshipKey)
+  const orm = Orm.instance;
+  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 instanceof Error ? err.message : String(err)}`);
+    });
+  }
 }
 
 /**
@@ -137,9 +162,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/orm-request.ts

@@ -330,7 +330,7 @@ export default class OrmRequest extends Request {
       }
 
       const recordAttributes = id !== undefined ? { id, ...sanitizedAttributes } : sanitizedAttributes;
-      const created = createRecord(model, recordAttributes as { [key: string]: unknown }, { serialize: false });
+      const created = createRecord(model, recordAttributes as { [key: string]: unknown }, { serialize: false, _skipAutoPersist: true });
       const record = isOrmRecord(created) ? created : null;
       if (!record) return 500;
 
@@ -368,7 +368,7 @@ export default class OrmRequest extends Request {
           }
         }
         if (Object.keys(relUpdates).length > 0) {
-          updateRecord(record as never, relUpdates);
+          updateRecord(record as never, relUpdates, { _skipAutoPersist: true });
         }
       }
 
@@ -443,9 +443,9 @@ export default class OrmRequest extends Request {
       // Execute main handler
       const response = await handler(request, state);
 
-      // Persist to SQL database for write operations
+      // Persist to SQL database for create/update (delete is handled by store.remove auto-persist)
       const sqlDb = Orm.instance.sqlDb;
-      if (sqlDb && WRITE_OPERATIONS.has(operation)) {
+      if (sqlDb && (operation === 'create' || operation === 'update')) {
         await sqlDb.persist(operation, this.model, context, response);
       }
 

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

@@ -176,6 +176,13 @@ export default class Store {
       throw new Error(`Cannot remove records from read-only view '${key}'`);
     }
 
+    // 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 instanceof Error ? err.message : String(err)}`);
+      });
+    }
+
     if (id) return this.unloadRecord(key, id);
 
     this.unloadAllRecords(key);