@stonyx/orm 0.3.2-alpha.124 → 0.3.2-alpha.126

package/dist/mysql/query-builder.d.ts

@@ -4,6 +4,7 @@ interface QueryResult {
 }
 export declare function validateIdentifier(name: string, context?: string): string;
 export declare function buildInsert(table: string, data: Record<string, unknown>): QueryResult;
+export declare function buildInsertMany(table: string, rows: Record<string, unknown>[]): QueryResult;
 export declare function buildUpdate(table: string, id: unknown, data: Record<string, unknown>): QueryResult;
 export declare function buildDelete(table: string, id: unknown): QueryResult;
 export declare function buildSelect(table: string, conditions?: Record<string, unknown>): QueryResult;

package/dist/mysql/query-builder.js

@@ -14,6 +14,23 @@ export function buildInsert(table, data) {
     const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(', ')}) VALUES (${placeholders.join(', ')})`;
     return { sql, values };
 }
+export function buildInsertMany(table, rows) {
+    validateIdentifier(table, 'table name');
+    const columns = [...new Set(rows.flatMap(row => Object.keys(row)))];
+    columns.forEach(column => validateIdentifier(column, 'column name'));
+    const values = [];
+    const tuples = rows.map(row => {
+        const cells = columns.map(column => {
+            if (!Object.hasOwn(row, column))
+                return 'DEFAULT';
+            values.push(row[column]);
+            return '?';
+        });
+        return `(${cells.join(', ')})`;
+    });
+    const sql = `INSERT INTO \`${table}\` (${columns.map(column => `\`${column}\``).join(', ')}) VALUES ${tuples.join(', ')}`;
+    return { sql, values };
+}
 export function buildUpdate(table, id, data) {
     validateIdentifier(table, 'table name');
     const keys = Object.keys(data);

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

@@ -85,6 +85,7 @@ export default class PostgresDB {
     deps: PostgresDeps;
     pool: Pool | null;
     pgConfig: Record<string, unknown>;
+    readonly persistResolvesAfterWrite = true;
     private _queuedWrites;
     private _inFlightWrites;
     private _drainingWrites;

package/dist/postgres/postgres-db.js

@@ -48,6 +48,7 @@ export default class PostgresDB {
     deps;
     pool;
     pgConfig;
+    persistResolvesAfterWrite = true;
     _queuedWrites = [];
     _inFlightWrites = new Set();
     _drainingWrites = null;

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.3.2-alpha.124",
+  "version": "0.3.2-alpha.126",
   "description": "",
   "main": "dist/index.js",
   "type": "module",
@@ -61,10 +61,10 @@
   },
   "homepage": "https://github.com/abofs/stonyx-orm#readme",
   "dependencies": {
-    "@stonyx/cron": "0.2.1-beta.174",
-    "@stonyx/events": "0.1.1-beta.73",
-    "@stonyx/utils": "0.2.3-beta.29",
-    "stonyx": "0.2.3-beta.108"
+    "@stonyx/cron": "0.2.1-beta.175",
+    "@stonyx/events": "0.1.1-beta.74",
+    "@stonyx/utils": "0.2.3-beta.30",
+    "stonyx": "0.2.3-beta.109"
   },
   "peerDependencies": {
     "@aws-sdk/client-dynamodb": "^3.0.0",
@@ -91,7 +91,7 @@
     }
   },
   "devDependencies": {
-    "@stonyx/rest-server": "0.2.1-beta.177",
+    "@stonyx/rest-server": "0.2.1-beta.178",
     "@types/node": "^25.6.0",
     "mysql2": "^3.20.0",
     "pg": "^8.20.0",

package/src/index.ts

@@ -21,14 +21,14 @@ import Serializer from './serializer.js';
 import attr from './attr.js';
 import belongsTo from './belongs-to.js';
 import hasMany from './has-many.js';
-import { createRecord, updateRecord } from './manage-record.js';
+import { createRecord, updateRecord, createRecordAndPersist, updateRecordAndPersist } 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 }; // base classes
-export { attr, belongsTo, hasMany, createRecord, updateRecord }; // helpers
+export { attr, belongsTo, hasMany, createRecord, updateRecord, createRecordAndPersist, updateRecordAndPersist };
 export { count, avg, sum, min, max }; // aggregate helpers
 export { default as normalizeRecordId } from './normalize-record-id.js'; // canonical URL-id -> record-id resolution (#270)
 export type { OrmRequest$ as OrmAccessRequest } from './orm-request.js'; // the request access() is handed, incl. recordId (#270)

package/src/main.ts

@@ -34,6 +34,7 @@ export interface SqlDb {
   startup(): Promise<void>;
   shutdown(): Promise<void>;
   persist(operation: string, model: string, context: unknown, response: unknown): Promise<void>;
+  persistResolvesAfterWrite?: boolean;
   findRecord(modelName: string, id: unknown): Promise<unknown>;
   findAll(modelName: string, conditions?: Record<string, unknown>): Promise<unknown[]>;
 }

package/src/manage-record.ts

@@ -28,7 +28,73 @@ const defaultOptions: CreateRecordOptions = {
 
 let pendingIdCounter = 0;
 
+interface RecordWrite<Result> {
+  result: Result;
+  written: Promise<void>;
+}
+
+type AwaitedOperation = 'create' | 'update';
+
+const writeNotRequested = Promise.resolve();
+
+function ignoreReportedFailure(): void {}
+
+function persistRequested(options: CreateRecordOptions, userOptions: CreateRecordOptions): boolean {
+  return !options.isDbRecord && !userOptions._relationshipKey && !options._skipAutoPersist;
+}
+
+function reportPersistFailure(operation: AwaitedOperation, modelName: string, recordId: unknown, failure: unknown): Error {
+  const error = failure instanceof Error ? failure : new Error(String(failure));
+  Orm.instance.emitPersistError({ operation, modelName, recordId, error });
+  return error;
+}
+
 export function createRecord(modelName: string, rawData: { [key: string]: unknown } = {}, userOptions: CreateRecordOptions = {}): OrmRecord {
+  const { result: record, written } = createRecordWrite(modelName, rawData, userOptions);
+  written.catch(ignoreReportedFailure);
+  return record;
+}
+
+export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: CreateRecordOptions = {}): void {
+  updateRecordWrite(record, rawData, userOptions).written.catch(ignoreReportedFailure);
+}
+
+export async function createRecordAndPersist(modelName: string, rawData: { [key: string]: unknown } = {}, userOptions: CreateRecordOptions = {}): Promise<OrmRecord> {
+  assertWriteCanBeAwaited();
+  const { result: record, written } = createRecordWrite(modelName, rawData, userOptions);
+  await written;
+  await saveJsonDatabase('create', modelName, record.id, { ...defaultOptions, ...userOptions }, userOptions);
+  return record;
+}
+
+export async function updateRecordAndPersist(record: OrmRecord, rawData: unknown, userOptions: CreateRecordOptions = {}): Promise<void> {
+  assertWriteCanBeAwaited();
+  await updateRecordWrite(record, rawData, userOptions).written;
+  await saveJsonDatabase('update', record?.__model?.__name ?? '', record.id, { ...defaultOptions, ...userOptions }, userOptions);
+}
+
+function assertWriteCanBeAwaited(): void {
+  const sqlDb = Orm.instance?.sqlDb as { persistResolvesAfterWrite?: boolean } | undefined;
+  if (sqlDb && sqlDb.persistResolvesAfterWrite !== true) {
+    throw new Error('The configured database adapter cannot confirm a write has landed, so createRecordAndPersist/updateRecordAndPersist are unavailable for it (DynamoDB: abofs/stonyx-orm#299)');
+  }
+}
+
+async function saveJsonDatabase(operation: AwaitedOperation, modelName: string, recordId: unknown, options: CreateRecordOptions, userOptions: CreateRecordOptions): Promise<void> {
+  const orm = Orm.instance;
+  if (orm.sqlDb || !persistRequested(options, userOptions)) return;
+
+  const jsonDatabase = orm.db as { save?: () => Promise<void> } | undefined;
+  if (!jsonDatabase?.save) return;
+
+  try {
+    await jsonDatabase.save();
+  } catch (failure) {
+    throw reportPersistFailure(operation, modelName, recordId, failure);
+  }
+}
+
+function createRecordWrite(modelName: string, rawData: { [key: string]: unknown }, userOptions: CreateRecordOptions): RecordWrite<OrmRecord> {
   const orm = Orm.instance;
   const { initialized } = Orm;
   const options = { ...defaultOptions, ...userOptions };
@@ -50,9 +116,7 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
   const existingRecord = modelStore.get(rawData.id as number | string);
 
   if (existingRecord instanceof OrmRecord) {
-    // Update the existing record with new data so the last entry wins
-    updateRecord(existingRecord, rawData, { ...options, update: true });
-    return existingRecord;
+    return { result: existingRecord, written: updateRecordWrite(existingRecord, rawData, { ...options, update: true }).written };
   }
 
   const recordClasses = orm.getRecordClasses(modelName);
@@ -136,37 +200,26 @@ 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) {
-    // Capture ID before persist — SQL adapters re-key pending IDs to real DB IDs,
-    // but relationship registries were keyed with this original ID
-    const registryId = record.id;
-    const response = { data: { id: record.id } };
-    orm!.sqlDb!.persist('create', modelName, { rawData }, response)
-      .catch((err: unknown) => {
-        orm!.emitPersistError({
-          operation: 'create',
-          modelName,
-          recordId: record.id,
-          error: err instanceof Error ? err : new Error(String(err)),
-        });
-      })
-      .finally(() => {
-        // Evict non-memory records after persist to prevent unbounded heap growth (stonyx#81)
-        if (store._memoryResolver && !store._memoryResolver(modelName)) {
-          store.evictRecord(modelName, record.id, registryId);
-        }
-      });
-  }
+  if (!orm?.sqlDb || !persistRequested(options, userOptions)) return { result: record, written: writeNotRequested };
+
+  const registryIdBeforePersist = record.id;
+  const response = { data: { id: record.id } };
+  const written = orm.sqlDb.persist('create', modelName, { rawData }, response)
+    .catch((failure: unknown) => {
+      throw reportPersistFailure('create', modelName, record.id, failure);
+    })
+    .finally(() => {
+      if (store._memoryResolver && !store._memoryResolver(modelName)) {
+        store.evictRecord(modelName, record.id, registryIdBeforePersist);
+      }
+    });
 
-  return record;
+  return { result: record, written };
 }
 
-export function updateRecord(record: OrmRecord, rawData: unknown, userOptions: CreateRecordOptions = {}): void {
+function updateRecordWrite(record: OrmRecord, rawData: unknown, userOptions: CreateRecordOptions): RecordWrite<void> {
   if (!rawData) throw new Error('rawData must be passed in to updateRecord call');
 
-  // Guard: read-only views cannot be updated
   const modelName = record?.__model?.__name;
   if (modelName && Orm.instance?.isView?.(modelName)) {
     throw new Error(`Cannot update records for read-only view '${modelName}'`);
@@ -174,24 +227,18 @@ 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) => {
-      orm!.emitPersistError({
-        operation: 'update',
-        modelName,
-        recordId: record.id,
-        error: err instanceof Error ? err : new Error(String(err)),
-      });
-    });
-  }
+  if (!orm?.sqlDb || !modelName || !persistRequested(options, userOptions)) return { result: undefined, written: writeNotRequested };
+
+  const written = orm.sqlDb.persist('update', modelName, { record, oldState }, {}).catch((failure: unknown) => {
+    throw reportPersistFailure('update', modelName, record.id, failure);
+  });
+
+  return { result: undefined, written };
 }
 
 /**

package/src/mysql/connection.ts

@@ -10,6 +10,8 @@ interface MysqlConfig {
   migrationsTable?: string;
   migrationsDir?: string;
   autoMigrate?: boolean;
+  writeBatchSize?: number;
+  writeQueueLimit?: number;
 }
 
 let pool: Pool | null = null;