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

package/README.md

@@ -1057,6 +1057,8 @@ test('validation hook rejects negative age', async () => {
 | `hasMany`       | Define a one-to-many relationship.                                      |
 | `createRecord`  | Instantiate a record with proper serialization and relationships.       |
 | `updateRecord`  | Update an existing record with new data.                                |
+| `createRecordAndPersist` | `createRecord`, awaited: resolves once the write has landed, rejects with its error. Not on DynamoDB yet (#299). |
+| `updateRecordAndPersist` | `updateRecord`, awaited: resolves once the write has landed, rejects with its error. Not on DynamoDB yet (#299). |
 | `store`         | Singleton store for all model instances.                                |
 | `relationships` | Access all relationships (`hasMany`, `belongsTo`, `global`, `pending`). |
 | `beforeHook`    | Register a before hook that can halt operations.                        |

package/config/environment.js

@@ -19,6 +19,8 @@ const {
   MYSQL_DATABASE,
   MYSQL_CONNECTION_LIMIT,
   MYSQL_MIGRATIONS_DIR,
+  MYSQL_WRITE_BATCH_SIZE,
+  MYSQL_WRITE_QUEUE_LIMIT,
   PG_HOST,
   PG_PORT,
   PG_USER,
@@ -70,6 +72,8 @@ export default {
     connectionLimit: parseInt(MYSQL_CONNECTION_LIMIT ?? '10'),
     migrationsDir: MYSQL_MIGRATIONS_DIR ?? 'migrations',
     migrationsTable: '__migrations',
+    writeBatchSize: parseInt(MYSQL_WRITE_BATCH_SIZE ?? '500'),
+    writeQueueLimit: parseInt(MYSQL_WRITE_QUEUE_LIMIT ?? '10000'),
   } : undefined,
   postgres: PG_HOST ? {
     host: PG_HOST ?? 'localhost',

package/dist/index.d.ts

@@ -4,13 +4,13 @@ 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 };
-export { attr, belongsTo, hasMany, createRecord, updateRecord };
+export { attr, belongsTo, hasMany, createRecord, updateRecord, createRecordAndPersist, updateRecordAndPersist };
 export { count, avg, sum, min, max };
 export { default as normalizeRecordId } from './normalize-record-id.js';
 export type { OrmRequest$ as OrmAccessRequest } from './orm-request.js';

package/dist/index.js

@@ -19,12 +19,12 @@ 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 { 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 { beforeHook, afterHook, clearHook, clearAllHooks } from './hooks.js'; // middleware hooks

package/dist/main.d.ts

@@ -7,6 +7,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/dist/manage-record.d.ts

@@ -11,4 +11,8 @@ export declare function createRecord(modelName: string, rawData?: {
     [key: string]: unknown;
 }, userOptions?: CreateRecordOptions): OrmRecord;
 export declare function updateRecord(record: OrmRecord, rawData: unknown, userOptions?: CreateRecordOptions): void;
+export declare function createRecordAndPersist(modelName: string, rawData?: {
+    [key: string]: unknown;
+}, userOptions?: CreateRecordOptions): Promise<OrmRecord>;
+export declare function updateRecordAndPersist(record: OrmRecord, rawData: unknown, userOptions?: CreateRecordOptions): Promise<void>;
 export {};

package/dist/manage-record.js

@@ -8,7 +8,57 @@ const defaultOptions = {
     transform: true
 };
 let pendingIdCounter = 0;
+const writeNotRequested = Promise.resolve();
+function ignoreReportedFailure() { }
+function persistRequested(options, userOptions) {
+    return !options.isDbRecord && !userOptions._relationshipKey && !options._skipAutoPersist;
+}
+function reportPersistFailure(operation, modelName, recordId, failure) {
+    const error = failure instanceof Error ? failure : new Error(String(failure));
+    Orm.instance.emitPersistError({ operation, modelName, recordId, error });
+    return error;
+}
 export function createRecord(modelName, rawData = {}, userOptions = {}) {
+    const { result: record, written } = createRecordWrite(modelName, rawData, userOptions);
+    written.catch(ignoreReportedFailure);
+    return record;
+}
+export function updateRecord(record, rawData, userOptions = {}) {
+    updateRecordWrite(record, rawData, userOptions).written.catch(ignoreReportedFailure);
+}
+export async function createRecordAndPersist(modelName, rawData = {}, userOptions = {}) {
+    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, rawData, userOptions = {}) {
+    assertWriteCanBeAwaited();
+    await updateRecordWrite(record, rawData, userOptions).written;
+    await saveJsonDatabase('update', record?.__model?.__name ?? '', record.id, { ...defaultOptions, ...userOptions }, userOptions);
+}
+function assertWriteCanBeAwaited() {
+    const sqlDb = Orm.instance?.sqlDb;
+    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, modelName, recordId, options, userOptions) {
+    const orm = Orm.instance;
+    if (orm.sqlDb || !persistRequested(options, userOptions))
+        return;
+    const jsonDatabase = orm.db;
+    if (!jsonDatabase?.save)
+        return;
+    try {
+        await jsonDatabase.save();
+    }
+    catch (failure) {
+        throw reportPersistFailure(operation, modelName, recordId, failure);
+    }
+}
+function createRecordWrite(modelName, rawData, userOptions) {
     const orm = Orm.instance;
     const { initialized } = Orm;
     const options = { ...defaultOptions, ...userOptions };
@@ -26,9 +76,7 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
     assignRecordId(modelName, rawData);
     const existingRecord = modelStore.get(rawData.id);
     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);
     const modelClass = recordClasses.modelClass;
@@ -101,56 +149,38 @@ 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) {
-        // 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) => {
-            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);
-            }
-        });
-    }
-    return record;
+    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) => {
+        throw reportPersistFailure('create', modelName, record.id, failure);
+    })
+        .finally(() => {
+        if (store._memoryResolver && !store._memoryResolver(modelName)) {
+            store.evictRecord(modelName, record.id, registryIdBeforePersist);
+        }
+    });
+    return { result: record, written };
 }
-export function updateRecord(record, rawData, userOptions = {}) {
+function updateRecordWrite(record, rawData, userOptions) {
     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}'`);
     }
     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) => {
-            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) => {
+        throw reportPersistFailure('update', modelName, record.id, failure);
+    });
+    return { result: undefined, written };
 }
 /**
  * gets the next available id based on last record entry.

package/dist/mysql/connection.d.ts

@@ -9,6 +9,8 @@ interface MysqlConfig {
     migrationsTable?: string;
     migrationsDir?: string;
     autoMigrate?: boolean;
+    writeBatchSize?: number;
+    writeQueueLimit?: number;
 }
 export declare function getPool(mysqlConfig: MysqlConfig): Promise<Pool>;
 export declare function closePool(): Promise<void>;

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

@@ -3,7 +3,7 @@ import type { MysqlConfig } from './connection.js';
 import { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } from './migration-runner.js';
 import { introspectModels, introspectViews, getTopologicalOrder, schemasToSnapshot } from './schema-introspector.js';
 import { loadLatestSnapshot, detectSchemaDrift } from './migration-generator.js';
-import { buildInsert, buildUpdate, buildDelete, buildSelect } from './query-builder.js';
+import { buildInsert, buildInsertMany, buildUpdate, buildDelete, buildSelect } from './query-builder.js';
 import { createRecord } from '../manage-record.js';
 import { confirm } from '@stonyx/utils/prompt';
 import { readFile } from '@stonyx/utils/file';
@@ -23,6 +23,13 @@ interface PersistResponse {
         id?: unknown;
     };
 }
+type ExitEmitter = Pick<NodeJS.Process, 'once' | 'removeListener'>;
+export declare class WriteQueueFullError extends Error {
+    constructor(limit: number);
+}
+export declare class WriteQueueClosedError extends Error {
+    constructor();
+}
 interface OrmStore {
     get(key: string): Map<number | string, unknown> | undefined;
     get(key: string, id: number | string): unknown;
@@ -44,6 +51,7 @@ interface MysqlDBDeps {
     loadLatestSnapshot: typeof loadLatestSnapshot;
     detectSchemaDrift: typeof detectSchemaDrift;
     buildInsert: typeof buildInsert;
+    buildInsertMany: typeof buildInsertMany;
     buildUpdate: typeof buildUpdate;
     buildDelete: typeof buildDelete;
     buildSelect: typeof buildSelect;
@@ -55,25 +63,30 @@ interface MysqlDBDeps {
     config: typeof config;
     log: Record<string, ((...args: unknown[]) => void) | undefined>;
     path: typeof path;
+    process: ExitEmitter;
 }
 export default class MysqlDB {
     static instance: MysqlDB | undefined;
     deps: MysqlDBDeps;
     pool: Pool | null;
     mysqlConfig: MysqlConfig;
-    /**
-     * Promise-chain mutex for write serialization (#156).
-     * All persist() calls chain through this single queue so concurrent
-     * fire-and-forget writes never produce parallel InnoDB transactions
-     * on FK-linked rows (which cause deadlocks).
-     * Reads are NOT affected — only persist() serializes.
-     */
-    private _writeQueue;
+    readonly persistResolvesAfterWrite = true;
+    private _queuedWrites;
+    private _inFlightWrites;
+    private _drainingWrites;
+    private _acceptingWrites;
+    private _exitReport;
     constructor(deps?: Partial<MysqlDBDeps>);
     private requirePool;
     init(): Promise<void>;
+    get writeBatchSize(): number;
+    get writeQueueLimit(): number;
+    get pendingWriteCount(): number;
     startup(): Promise<void>;
     shutdown(): Promise<void>;
+    private _registerExitReport;
+    private _unregisterExitReport;
+    private _reportUnpersistedWrites;
     save(): Promise<void>;
     /**
      * Loads only models with memory: true into the in-memory store on startup.
@@ -101,7 +114,16 @@ export default class MysqlDB {
     private _evictIfNotMemory;
     private _rowToRawData;
     persist(operation: string, modelName: string, context: PersistContext, response: PersistResponse): Promise<void>;
-    private _persistCreate;
+    private _drainWritesInBackground;
+    private _drainQueuedWrites;
+    private _takeNextWriteGroup;
+    private _executeWriteGroup;
+    private _persistCreates;
+    private _prepareCreate;
+    private _chunkForSingleInsert;
+    private _insertCreates;
+    private _insertCreatesOneByOne;
+    private _adoptGeneratedId;
     private _persistUpdate;
     private _persistDelete;
     private _recordToRow;

package/dist/mysql/mysql-db.js

@@ -2,7 +2,7 @@ import { getPool, closePool } from './connection.js';
 import { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } from './migration-runner.js';
 import { introspectModels, introspectViews, getTopologicalOrder, schemasToSnapshot } from './schema-introspector.js';
 import { loadLatestSnapshot, detectSchemaDrift } from './migration-generator.js';
-import { buildInsert, buildUpdate, buildDelete, buildSelect } from './query-builder.js';
+import { buildInsert, buildInsertMany, buildUpdate, buildDelete, buildSelect } from './query-builder.js';
 import { store } from '@stonyx/orm';
 import { createRecord } from '../manage-record.js';
 import { confirm } from '@stonyx/utils/prompt';
@@ -12,28 +12,41 @@ import { isDbError } from '../utils.js';
 import config from 'stonyx/config';
 import log from 'stonyx/log';
 import path from 'path';
+const MYSQL_MAX_PLACEHOLDERS = 65535;
+const DEFAULT_WRITE_BATCH_SIZE = 500;
+const DEFAULT_WRITE_QUEUE_LIMIT = 10000;
+export class WriteQueueFullError extends Error {
+    constructor(limit) {
+        super(`MysqlDB write queue is full (${limit} queued writes, writeQueueLimit); the write was rejected`);
+        this.name = 'WriteQueueFullError';
+    }
+}
+export class WriteQueueClosedError extends Error {
+    constructor() {
+        super('MysqlDB is shutting down; the write was rejected');
+        this.name = 'WriteQueueClosedError';
+    }
+}
 const defaultDeps = {
     getPool, closePool, ensureMigrationsTable, getAppliedMigrations,
     getMigrationFiles, applyMigration, parseMigrationFile,
     introspectModels, introspectViews, getTopologicalOrder, schemasToSnapshot,
     loadLatestSnapshot, detectSchemaDrift,
-    buildInsert, buildUpdate, buildDelete, buildSelect,
+    buildInsert, buildInsertMany, buildUpdate, buildDelete, buildSelect,
     createRecord, store: store, confirm, readFile, getPluralName,
-    config, log, path
+    config, log, path, process
 };
 export default class MysqlDB {
     static instance;
     deps;
     pool;
     mysqlConfig;
-    /**
-     * Promise-chain mutex for write serialization (#156).
-     * All persist() calls chain through this single queue so concurrent
-     * fire-and-forget writes never produce parallel InnoDB transactions
-     * on FK-linked rows (which cause deadlocks).
-     * Reads are NOT affected — only persist() serializes.
-     */
-    _writeQueue = Promise.resolve();
+    persistResolvesAfterWrite = true;
+    _queuedWrites = [];
+    _inFlightWrites = new Set();
+    _drainingWrites = null;
+    _acceptingWrites = true;
+    _exitReport = null;
     constructor(deps = {}) {
         if (MysqlDB.instance)
             return MysqlDB.instance;
@@ -54,6 +67,17 @@ export default class MysqlDB {
         this.pool = await this.deps.getPool(this.mysqlConfig);
         await this.deps.ensureMigrationsTable(this.pool, this.mysqlConfig.migrationsTable);
         await this.loadMemoryRecords();
+        this._acceptingWrites = true;
+        this._registerExitReport();
+    }
+    get writeBatchSize() {
+        return Number(this.mysqlConfig?.writeBatchSize) || DEFAULT_WRITE_BATCH_SIZE;
+    }
+    get writeQueueLimit() {
+        return Number(this.mysqlConfig?.writeQueueLimit) || DEFAULT_WRITE_QUEUE_LIMIT;
+    }
+    get pendingWriteCount() {
+        return this._inFlightWrites.size + this._queuedWrites.length;
     }
     async startup() {
         if (!this.mysqlConfig.migrationsDir)
@@ -134,9 +158,35 @@ export default class MysqlDB {
         }
     }
     async shutdown() {
+        this._acceptingWrites = false;
+        while (this._drainingWrites)
+            await this._drainingWrites;
+        this._unregisterExitReport();
         await this.deps.closePool();
         this.pool = null;
     }
+    _registerExitReport() {
+        if (this._exitReport)
+            return;
+        this._exitReport = () => this._reportUnpersistedWrites();
+        this.deps.process.once('exit', this._exitReport);
+    }
+    _unregisterExitReport() {
+        if (!this._exitReport)
+            return;
+        this.deps.process.removeListener('exit', this._exitReport);
+        this._exitReport = null;
+    }
+    _reportUnpersistedWrites() {
+        const lostWrites = [...this._inFlightWrites, ...this._queuedWrites];
+        if (lostWrites.length === 0)
+            return;
+        const lostByModel = new Map();
+        for (const { modelName } of lostWrites)
+            lostByModel.set(modelName, (lostByModel.get(modelName) ?? 0) + 1);
+        const breakdown = [...lostByModel].map(([modelName, count]) => `${modelName}: ${count}`).join(', ');
+        this.deps.log.error?.(`[MysqlDB] Process exiting with ${lostWrites.length} queued write(s) not persisted; they are lost (${breakdown})`);
+    }
     async save() {
         // No-op: MySQL persists data immediately via persist()
     }
@@ -326,64 +376,174 @@ export default class MysqlDB {
         return rawData;
     }
     async persist(operation, modelName, context, response) {
-        // Views are read-only — no-op for all write operations
         const Orm = (await import('@stonyx/orm')).default;
         if (Orm.instance?.isView?.(modelName))
             return;
-        const work = async () => {
-            switch (operation) {
-                case 'create':
-                    return this._persistCreate(modelName, context, response);
-                case 'update':
-                    return this._persistUpdate(modelName, context, response);
-                case 'delete':
-                    return this._persistDelete(modelName, context);
-            }
-        };
-        // Chain through the write queue — .then(work, work) ensures the queue
-        // advances even when a previous persist rejects (#156).
-        this._writeQueue = this._writeQueue.then(work, work);
-        return this._writeQueue;
-    }
-    async _persistCreate(modelName, context, response) {
-        const schemas = this.deps.introspectModels();
-        const schema = schemas[modelName];
-        if (!schema)
+        if (!this._acceptingWrites)
+            throw new WriteQueueClosedError();
+        if (this._queuedWrites.length >= this.writeQueueLimit)
+            throw new WriteQueueFullError(this.writeQueueLimit);
+        return new Promise((resolve, reject) => {
+            const write = {
+                operation, modelName, context, response,
+                resolve: () => {
+                    this._inFlightWrites.delete(write);
+                    resolve();
+                },
+                reject: (error) => {
+                    this._inFlightWrites.delete(write);
+                    reject(error);
+                },
+            };
+            this._queuedWrites.push(write);
+            this._drainWritesInBackground();
+        });
+    }
+    _drainWritesInBackground() {
+        if (this._drainingWrites)
             return;
+        this._drainingWrites = this._drainQueuedWrites().finally(() => {
+            this._drainingWrites = null;
+        });
+    }
+    async _drainQueuedWrites() {
+        while (this._queuedWrites.length > 0) {
+            const writes = this._takeNextWriteGroup();
+            writes.forEach(write => this._inFlightWrites.add(write));
+            try {
+                await this._executeWriteGroup(writes);
+            }
+            catch (error) {
+                writes.filter(write => this._inFlightWrites.has(write)).forEach(write => write.reject(error));
+            }
+        }
+    }
+    _takeNextWriteGroup() {
+        const [first] = this._queuedWrites;
+        let groupSize = 1;
+        if (first.operation === 'create') {
+            while (groupSize < this.writeBatchSize
+                && groupSize < this._queuedWrites.length
+                && this._queuedWrites[groupSize].operation === 'create'
+                && this._queuedWrites[groupSize].modelName === first.modelName)
+                groupSize++;
+        }
+        return this._queuedWrites.splice(0, groupSize);
+    }
+    async _executeWriteGroup(writes) {
+        const [first] = writes;
+        if (first.operation === 'create')
+            return this._persistCreates(first.modelName, writes);
+        try {
+            if (first.operation === 'update')
+                await this._persistUpdate(first.modelName, first.context, first.response);
+            if (first.operation === 'delete')
+                await this._persistDelete(first.modelName, first.context);
+            first.resolve();
+        }
+        catch (error) {
+            first.reject(error);
+        }
+    }
+    async _persistCreates(modelName, writes) {
+        const schema = this.deps.introspectModels()[modelName];
+        const prepared = [];
+        for (const write of writes) {
+            try {
+                const create = schema ? this._prepareCreate(modelName, schema, write) : null;
+                if (create)
+                    prepared.push(create);
+                else
+                    write.resolve();
+            }
+            catch (error) {
+                write.reject(error);
+            }
+        }
+        for (const chunk of this._chunkForSingleInsert(prepared)) {
+            await this._insertCreates(schema, chunk);
+        }
+    }
+    _prepareCreate(modelName, schema, write) {
+        const { context, response } = write;
         const recordId = response?.data?.id;
         const record = recordId != null ? this.deps.store.get(modelName, (isNaN(recordId) ? recordId : parseInt(recordId))) : null;
         if (!record)
-            return;
-        const insertData = this._recordToRow(record, schema);
-        // 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.
+            return null;
+        const row = this._recordToRow(record, schema);
         const isPendingId = context.rawData?.__pendingSqlId === true;
-        if (isPendingId) {
-            delete insertData.id;
+        if (isPendingId)
+            delete row.id;
+        return { write, modelName, record, row, isPendingId };
+    }
+    _chunkForSingleInsert(prepared) {
+        const chunks = [];
+        let chunk = [];
+        let chunkColumns = new Set();
+        for (const create of prepared) {
+            const columnsWithCreate = new Set([...chunkColumns, ...Object.keys(create.row)]);
+            const mixesIdSources = chunk.length > 0 && chunk[0].isPendingId !== create.isPendingId;
+            const exceedsPlaceholders = (chunk.length + 1) * columnsWithCreate.size > MYSQL_MAX_PLACEHOLDERS;
+            if (chunk.length > 0 && (mixesIdSources || exceedsPlaceholders)) {
+                chunks.push(chunk);
+                chunk = [];
+                chunkColumns = new Set(Object.keys(create.row));
+            }
+            else {
+                chunkColumns = columnsWithCreate;
+            }
+            chunk.push(create);
         }
-        else if (insertData.id !== undefined) {
-            // Keep user-provided ID (string IDs or explicit numeric IDs)
+        if (chunk.length > 0)
+            chunks.push(chunk);
+        return chunks;
+    }
+    async _insertCreates(schema, creates) {
+        if (creates.length === 1)
+            return this._insertCreatesOneByOne(schema, creates);
+        let firstInsertId;
+        try {
+            const { sql, values } = this.deps.buildInsertMany(schema.table, creates.map(({ row }) => row));
+            const [result] = await this.requirePool().execute(sql, values);
+            firstInsertId = result.insertId;
         }
-        const { sql, values } = this.deps.buildInsert(schema.table, insertData);
-        const [result] = await this.requirePool().execute(sql, values);
-        // Re-key the record in the store if MySQL generated the ID
-        if (isPendingId && result.insertId) {
-            const pendingId = record.id;
-            const realId = result.insertId;
-            const modelStore = this.deps.store.get(modelName);
-            if (!modelStore)
-                throw new Error(`Model "${modelName}" not found in store during ID re-key`);
-            modelStore.delete(pendingId);
-            record.__data.id = realId;
-            record.id = realId;
-            modelStore.set(realId, record);
-            // Update the response data with the real ID
-            if (response?.data) {
-                response.data.id = realId;
-            }
-            delete record.__data.__pendingSqlId;
+        catch {
+            return this._insertCreatesOneByOne(schema, creates);
         }
+        creates.forEach((create, index) => {
+            if (firstInsertId)
+                this._adoptGeneratedId(create, firstInsertId + index);
+            create.write.resolve();
+        });
+    }
+    async _insertCreatesOneByOne(schema, creates) {
+        for (const create of creates) {
+            try {
+                const { sql, values } = this.deps.buildInsert(schema.table, create.row);
+                const [result] = await this.requirePool().execute(sql, values);
+                if (result.insertId)
+                    this._adoptGeneratedId(create, result.insertId);
+                create.write.resolve();
+            }
+            catch (error) {
+                create.write.reject(error);
+            }
+        }
+    }
+    _adoptGeneratedId({ modelName, record, isPendingId, write }, realId) {
+        if (!isPendingId)
+            return;
+        const pendingId = record.id;
+        const modelStore = this.deps.store.get(modelName);
+        if (!modelStore)
+            throw new Error(`Model "${modelName}" not found in store during ID re-key`);
+        modelStore.delete(pendingId);
+        record.__data.id = realId;
+        record.id = realId;
+        modelStore.set(realId, record);
+        if (write.response?.data)
+            write.response.data.id = realId;
+        delete record.__data.__pendingSqlId;
     }
     async _persistUpdate(modelName, context, response) {
         const schemas = this.deps.introspectModels();