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

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,6 +2,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';
+import log from 'stonyx/log';
 const defaultOptions = {
     isDbRecord: false,
     serialize: true,
@@ -79,6 +80,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);
+        });
+    }
     return record;
 }
 export function updateRecord(record, rawData, userOptions = {}) {
@@ -90,7 +99,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);
+        });
+    }
 }
 /**
  * gets the next available id based on last record entry.

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/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);
+            });
+        }
         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.6",
   "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;
 }
 
@@ -111,6 +113,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);
+    });
+  }
+
   return record;
 }
 
@@ -125,7 +136,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);
+    });
+  }
 }
 
 /**

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/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);
+      });
+    }
+
     if (id) return this.unloadRecord(key, id);
 
     this.unloadAllRecords(key);