@stonyx/orm 0.3.2-beta.33 → 0.3.2-beta.330

package/dist/dynamodb/operation-builder.js

@@ -0,0 +1,116 @@
+/**
+ * DynamoDB operation parameter builders.
+ *
+ * Each function returns a plain-object "params" bag that can be passed
+ * directly to the corresponding DocumentClient command
+ * (PutCommand, GetCommand, UpdateCommand, DeleteCommand, ScanCommand, QueryCommand).
+ *
+ * All functions are pure — no SDK imports here; the caller wraps params
+ * in the appropriate Command class.
+ */
+/**
+ * PutItem — optionally with a condition expression.
+ *
+ * Pass conditionExpression = 'attribute_not_exists(id)' to enforce uniqueness.
+ */
+export function buildPutItem(tableName, item, conditionExpression) {
+    const params = { TableName: tableName, Item: item };
+    if (conditionExpression)
+        params.ConditionExpression = conditionExpression;
+    return params;
+}
+/**
+ * GetItem by primary key.
+ */
+export function buildGetItem(tableName, key) {
+    return { TableName: tableName, Key: key };
+}
+/**
+ * UpdateItem with a SET expression built from the `updates` object.
+ * Only the supplied attributes are updated (diff-based call site).
+ */
+export function buildUpdateItem(tableName, key, updates) {
+    const names = {};
+    const values = {};
+    const setClauses = [];
+    for (const [attr, val] of Object.entries(updates)) {
+        const nameAlias = `#${attr}`;
+        const valAlias = `:${attr}`;
+        names[nameAlias] = attr;
+        values[valAlias] = val;
+        setClauses.push(`${nameAlias} = ${valAlias}`);
+    }
+    return {
+        TableName: tableName,
+        Key: key,
+        UpdateExpression: `SET ${setClauses.join(', ')}`,
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: values,
+        ReturnValues: 'NONE',
+    };
+}
+/**
+ * DeleteItem by primary key.
+ */
+export function buildDeleteItem(tableName, key) {
+    return { TableName: tableName, Key: key };
+}
+/**
+ * ScanCommand params.
+ * If conditions are supplied they are rendered as a FilterExpression using AND.
+ */
+export function buildScan(tableName, conditions, exclusiveStartKey) {
+    const params = { TableName: tableName };
+    if (exclusiveStartKey)
+        params.ExclusiveStartKey = exclusiveStartKey;
+    if (conditions && Object.keys(conditions).length > 0) {
+        const validEntries = Object.entries(conditions).filter(([, val]) => val !== undefined && val !== null);
+        if (validEntries.length > 0) {
+            const names = {};
+            const values = {};
+            const clauses = [];
+            for (const [attr, val] of validEntries) {
+                const nameAlias = `#${attr}`;
+                const valAlias = `:${attr}`;
+                names[nameAlias] = attr;
+                values[valAlias] = val;
+                clauses.push(`${nameAlias} = ${valAlias}`);
+            }
+            params.FilterExpression = clauses.join(' AND ');
+            params.ExpressionAttributeNames = names;
+            params.ExpressionAttributeValues = values;
+        }
+    }
+    return params;
+}
+/**
+ * QueryCommand params for a GSI.
+ * keyConditions must be in the form { attrName: value } and will be rendered
+ * as equality expressions joined by AND.
+ */
+export function buildQuery(tableName, indexName, keyConditions, exclusiveStartKey) {
+    const validEntries = Object.entries(keyConditions).filter(([, val]) => val !== undefined && val !== null);
+    if (validEntries.length === 0) {
+        throw new Error('buildQuery: all keyCondition values are undefined/null');
+    }
+    const names = {};
+    const values = {};
+    const clauses = [];
+    for (const [attr, val] of validEntries) {
+        const nameAlias = `#${attr}`;
+        const valAlias = `:${attr}`;
+        names[nameAlias] = attr;
+        values[valAlias] = val;
+        clauses.push(`${nameAlias} = ${valAlias}`);
+    }
+    const params = {
+        TableName: tableName,
+        IndexName: indexName,
+        KeyConditionExpression: clauses.join(' AND '),
+        ExpressionAttributeNames: names,
+        ExpressionAttributeValues: values,
+    };
+    if (exclusiveStartKey)
+        params.ExclusiveStartKey = exclusiveStartKey;
+    return params;
+}

package/dist/dynamodb/type-map.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Maps ORM attribute types to DynamoDB scalar attribute types.
+ * DynamoDB DocumentClient auto-marshalls JS objects, so most values
+ * are sent as their native JS types.  This map is used by the
+ * schema-introspector and startup provisioner for table/GSI creation.
+ */
+export type DynamoScalarType = 'S' | 'N' | 'BOOL';
+/**
+ * DynamoDB attribute-type string for a given ORM attr type.
+ * - string            → S
+ * - number / float    → N  (stored as Number; DocumentClient handles it)
+ * - boolean           → BOOL
+ * - date              → S  (ISO-8601 string — enables range queries)
+ * - timestamp         → N  (milliseconds since epoch)
+ * - passthrough/trim/etc → S  (safe default)
+ *
+ * For key schema declarations only `S` and `N` are valid; BOOL
+ * is legal for attributes but never for a PK/SK.
+ */
+declare const typeMap: Record<string, DynamoScalarType>;
+/**
+ * Returns the DynamoDB attribute type for a given ORM type string.
+ * Defaults to 'S' for any unknown/custom type.
+ */
+export declare function getDynamoType(attrType: string): DynamoScalarType;
+/**
+ * Returns the DynamoDB key type ('S' | 'N') for use in KeySchema.
+ * BOOL cannot be a key attribute; anything that maps to BOOL falls back to 'S'.
+ */
+export declare function getDynamoKeyType(attrType: string): 'S' | 'N';
+export default typeMap;

package/dist/dynamodb/type-map.js

@@ -0,0 +1,48 @@
+/**
+ * Maps ORM attribute types to DynamoDB scalar attribute types.
+ * DynamoDB DocumentClient auto-marshalls JS objects, so most values
+ * are sent as their native JS types.  This map is used by the
+ * schema-introspector and startup provisioner for table/GSI creation.
+ */
+/**
+ * DynamoDB attribute-type string for a given ORM attr type.
+ * - string            → S
+ * - number / float    → N  (stored as Number; DocumentClient handles it)
+ * - boolean           → BOOL
+ * - date              → S  (ISO-8601 string — enables range queries)
+ * - timestamp         → N  (milliseconds since epoch)
+ * - passthrough/trim/etc → S  (safe default)
+ *
+ * For key schema declarations only `S` and `N` are valid; BOOL
+ * is legal for attributes but never for a PK/SK.
+ */
+const typeMap = {
+    string: 'S',
+    number: 'N',
+    float: 'N',
+    boolean: 'BOOL',
+    date: 'S',
+    timestamp: 'N',
+    passthrough: 'S',
+    trim: 'S',
+    uppercase: 'S',
+    ceil: 'N',
+    floor: 'N',
+    round: 'N',
+};
+/**
+ * Returns the DynamoDB attribute type for a given ORM type string.
+ * Defaults to 'S' for any unknown/custom type.
+ */
+export function getDynamoType(attrType) {
+    return typeMap[attrType] ?? 'S';
+}
+/**
+ * Returns the DynamoDB key type ('S' | 'N') for use in KeySchema.
+ * BOOL cannot be a key attribute; anything that maps to BOOL falls back to 'S'.
+ */
+export function getDynamoKeyType(attrType) {
+    const t = getDynamoType(attrType);
+    return t === 'N' ? 'N' : 'S';
+}
+export default typeMap;

package/dist/index.d.ts

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

package/dist/index.js

@@ -19,13 +19,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 { 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
 // Store API:
 // store.get(model, id)   -- sync, memory-only

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/main.js

@@ -19,7 +19,6 @@ import log from 'stonyx/log';
 import { forEachFileImport } from '@stonyx/utils/file';
 import { kebabCaseToPascalCase, pluralize } from '@stonyx/utils/string';
 import { registerPluralName } from './plural-registry.js';
-import setupRestServer from './setup-rest-server.js';
 import baseTransforms from './transforms.js';
 import Store from './store.js';
 import Serializer from './serializer.js';
@@ -54,6 +53,10 @@ export default class Orm {
         Orm.instance = this;
     }
     async init() {
+        // Self-register so log.db works even when @stonyx/orm is in the
+        // consumer's `dependencies` (stonyx loader only merges devDependencies).
+        const { logColor = 'white', logMethod = 'db' } = config.orm;
+        log.defineType(logMethod, logColor);
         const { paths, restServer } = config.orm;
         const promises = ['Model', 'Serializer', 'Transform'].map(type => {
             const lowerCaseType = type.toLowerCase();
@@ -115,12 +118,37 @@ export default class Orm {
             this.db = this.sqlDb;
             promises.push(this.sqlDb.init());
         }
+        else if (config.orm.dynamodb) {
+            const { default: DynamoDBDB } = await import('./dynamodb/dynamodb-db.js');
+            this.sqlDb = new DynamoDBDB();
+            this.db = this.sqlDb;
+            promises.push(this.sqlDb.init());
+        }
         else if (this.options.dbType !== 'none') {
             const db = new DB();
             this.db = db;
             promises.push(db.init());
         }
         if (restServer.enabled === 'true') {
+            // MUST stay dynamic. setup-rest-server.js names the optional
+            // '@stonyx/rest-server' peer in its own static graph — directly, and
+            // through orm-request.ts / meta-request.ts, which import `Request` at
+            // module scope because they extend it (correctly: an `extends` base
+            // class cannot be awaited). Node links a module's entire static graph
+            // before evaluating any of it, so a static import here puts that
+            // specifier on the entry graph and `import('@stonyx/orm')` throws
+            // ERR_MODULE_NOT_FOUND for an ORM-only consumer that never installed the
+            // optional peer.
+            //
+            // NOT the same reason the SQL/DynamoDB drivers above are lazy: those
+            // modules carry no static peer specifier that survives to `dist/`
+            // (postgres-db.ts:15 and mysql-db.ts:17 are `import type`, erased by
+            // tsc), so the `await import()` there is not what isolates pg / mysql2 /
+            // @aws-sdk — that happens one layer down, in src/*/connection.ts (and
+            // src/dynamodb/dynamodb-db.ts).
+            // setup-rest-server.js is the only dist module whose laziness is
+            // load-bearing for peer resolution. (#280)
+            const { default: setupRestServer } = await import('./setup-rest-server.js');
             promises.push(setupRestServer(restServer.route, paths.access, restServer.metaRoute));
         }
         // Wire up memory resolver so store.find() can check model memory flags

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;
@@ -52,13 +100,34 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
             relationship.push(record);
         pendingHasMany.splice(0);
     }
+    // FK-based inverse hasMany wiring — when a child record is created with a
+    // foreign-key field (e.g. `owner: 'owner-1'` on an animal), find any parent
+    // whose hasMany registry targets this model and push the child into the
+    // parent's shared array.  This covers edge cases where the child is created
+    // in a separate async frame without a belongsTo handler firing.
+    const hasManyReg = getHasManyRegistry();
+    if (hasManyReg) {
+        for (const [parentModelName, targetMap] of hasManyReg) {
+            const childArrayMap = targetMap.get(modelName);
+            if (!childArrayMap)
+                continue;
+            // Check if rawData contains a FK field matching the parent model name
+            const fkValue = rawData[parentModelName];
+            if (fkValue === undefined || fkValue === null)
+                continue;
+            const parentArray = childArrayMap.get(fkValue);
+            if (parentArray && !parentArray.includes(record)) {
+                parentArray.push(record);
+            }
+        }
+    }
     // Fulfill pending belongsTo relationships
     const pendingBelongsToQueue = getPendingBelongsToRegistry();
     const pendingBelongsToRaw = pendingBelongsToQueue.get(modelName)?.get(record.id);
     const pendingBelongsTo = Array.isArray(pendingBelongsToRaw) ? pendingBelongsToRaw : undefined;
     if (pendingBelongsTo) {
         const belongsToReg = getBelongsToRegistry();
-        const hasManyReg = getHasManyRegistry();
+        const pendingHasManyReg = getHasManyRegistry();
         for (const { sourceRecord, sourceModelName, relationshipKey, relationshipId } of pendingBelongsTo) {
             // Update the belongsTo relationship on the source record
             sourceRecord.__relationships[relationshipKey] = record;
@@ -72,7 +141,7 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
                 }
             }
             // Wire inverse hasMany if it exists
-            const inverseHasMany = hasManyReg.get(modelName)?.get(sourceModelName)?.get(record.id);
+            const inverseHasMany = pendingHasManyReg.get(modelName)?.get(sourceModelName)?.get(record.id);
             if (inverseHasMany && !inverseHasMany.includes(sourceRecord)) {
                 inverseHasMany.push(sourceRecord);
             }
@@ -80,46 +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) {
-        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)),
-            });
-        });
-    }
-    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

@@ -8,6 +8,9 @@ interface MysqlConfig {
     connectionLimit?: number;
     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,17 +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;
+    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.
@@ -93,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;