@stonyx/orm 0.3.2-beta.4 → 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, {}, 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/postgres/postgres-db.d.ts

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

package/dist/postgres/postgres-db.js

@@ -365,7 +365,7 @@ export default class PostgresDB {
                 return this._persistDelete(modelName, context);
         }
     }
-    async _persistCreate(modelName, _context, response) {
+    async _persistCreate(modelName, context, response) {
         const schemas = this.deps.introspectModels();
         const schema = schemas[modelName];
         if (!schema)
@@ -375,7 +375,7 @@ export default class PostgresDB {
         const record = recordId != null ? storeRef.get(modelName, isNaN(recordId) ? recordId : parseInt(recordId)) : null;
         if (!record)
             return;
-        const insertData = this._recordToRow(record, schema);
+        const insertData = this._recordToRow(record, schema, context.rawData);
         // For auto-increment models, remove the pending ID
         const isPendingId = record.__data.__pendingSqlId;
         if (isPendingId) {
@@ -420,7 +420,10 @@ export default class PostgresDB {
         // Check FK changes too
         for (const fkCol of Object.keys(schema.foreignKeys)) {
             const relName = fkCol.replace(/_id$/, '');
-            const currentFkValue = record.__relationships[relName]?.id ?? null;
+            const relValue = record.__relationships[relName];
+            const currentFkValue = (relValue && typeof relValue === 'object' && relValue !== null)
+                ? relValue.id ?? null
+                : relValue ?? record.__data[relName] ?? null;
             const oldFkValue = oldState[relName] ?? null;
             if (currentFkValue !== oldFkValue) {
                 changedData[fkCol] = currentFkValue;
@@ -444,7 +447,7 @@ export default class PostgresDB {
         const { sql, values } = this.deps.buildDelete(schema.table, id);
         await this.requirePool().query(sql, values);
     }
-    _recordToRow(record, schema) {
+    _recordToRow(record, schema, rawData) {
         const row = {};
         const data = record.__data;
         // ID
@@ -464,13 +467,20 @@ export default class PostgresDB {
         for (const fkCol of Object.keys(schema.foreignKeys)) {
             const relName = fkCol.replace(/_id$/, '');
             const related = record.__relationships[relName];
-            if (related) {
+            if (related && typeof related === 'object' && related !== null) {
                 row[fkCol] = related.id;
             }
+            else if (related != null) {
+                // Raw FK value (e.g., string ID stored directly in __relationships)
+                row[fkCol] = related;
+            }
             else if (data[relName] !== undefined) {
-                // Raw FK value (e.g., from create payload)
                 row[fkCol] = data[relName];
             }
+            else if (rawData?.[relName] !== undefined) {
+                // Fallback to original create payload for unresolved belongsTo FKs
+                row[fkCol] = rawData[relName];
+            }
         }
         return row;
     }

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.4",
+  "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, {}, 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/postgres/postgres-db.ts

@@ -19,6 +19,7 @@ interface PersistContext {
   record?: OrmRecord;
   recordId?: unknown;
   oldState?: Record<string, unknown>;
+  rawData?: Record<string, unknown>;
 }
 
 interface PersistResponse {
@@ -477,7 +478,7 @@ export default class PostgresDB {
     }
   }
 
-  private async _persistCreate(modelName: string, _context: PersistContext, response: PersistResponse): Promise<void> {
+  private async _persistCreate(modelName: string, context: PersistContext, response: PersistResponse): Promise<void> {
     const schemas = this.deps.introspectModels();
     const schema = schemas[modelName];
 
@@ -491,7 +492,7 @@ export default class PostgresDB {
 
     if (!record) return;
 
-    const insertData = this._recordToRow(record, schema);
+    const insertData = this._recordToRow(record, schema, context.rawData);
 
     // For auto-increment models, remove the pending ID
     const isPendingId = record.__data.__pendingSqlId;
@@ -549,7 +550,10 @@ export default class PostgresDB {
     // Check FK changes too
     for (const fkCol of Object.keys(schema.foreignKeys)) {
       const relName = fkCol.replace(/_id$/, '');
-      const currentFkValue = (record.__relationships[relName] as { id: unknown } | undefined)?.id ?? null;
+      const relValue = record.__relationships[relName];
+      const currentFkValue = (relValue && typeof relValue === 'object' && relValue !== null)
+        ? (relValue as { id: unknown }).id ?? null
+        : relValue ?? record.__data[relName] ?? null;
       const oldFkValue = oldState[relName] ?? null;
 
       if (currentFkValue !== oldFkValue) {
@@ -579,7 +583,7 @@ export default class PostgresDB {
     await this.requirePool().query(sql, values);
   }
 
-  private _recordToRow(record: OrmRecord, schema: ModelSchema): Record<string, unknown> {
+  private _recordToRow(record: OrmRecord, schema: ModelSchema, rawData?: Record<string, unknown>): Record<string, unknown> {
     const row: Record<string, unknown> = {};
     const data = record.__data;
 
@@ -603,11 +607,16 @@ export default class PostgresDB {
       const relName = fkCol.replace(/_id$/, '');
       const related = record.__relationships[relName];
 
-      if (related) {
+      if (related && typeof related === 'object' && related !== null) {
         row[fkCol] = (related as { id: unknown }).id;
+      } else if (related != null) {
+        // Raw FK value (e.g., string ID stored directly in __relationships)
+        row[fkCol] = related;
       } else if (data[relName] !== undefined) {
-        // Raw FK value (e.g., from create payload)
         row[fkCol] = data[relName];
+      } else if (rawData?.[relName] !== undefined) {
+        // Fallback to original create payload for unresolved belongsTo FKs
+        row[fkCol] = rawData[relName];
       }
     }
 

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