@stonyx/orm 0.3.2-alpha.11 → 0.3.2-alpha.111

package/src/dynamodb/connection.ts

@@ -8,6 +8,7 @@
 export interface DynamoDBConfig {
   region?: string;
   endpoint?: string;
+  tablePrefix?: string;
   [key: string]: unknown;
 }
 
@@ -17,27 +18,27 @@ export type DocumentClient = {
   send(command: unknown): Promise<unknown>;
 };
 
-export type DocumentClientConstructor = new (options: { client: unknown }) => DocumentClient;
-export type DynamoDBClientConstructor = new (options: unknown) => unknown;
+export type DynamoDBClientConstructor = new (options: unknown) => { config: unknown };
+export type DocumentClientFromFn = { from(client: unknown): DocumentClient };
 
 /**
  * Create a DynamoDBDocumentClient from the given config.
  * Uses dynamic import so @aws-sdk/* are optional peer deps.
  */
 export async function createDocumentClient(dbConfig: DynamoDBConfig): Promise<DocumentClient> {
-  const { DynamoDB } = await import('@aws-sdk/client-dynamodb' as string) as {
-    DynamoDB: DynamoDBClientConstructor;
+  const { DynamoDBClient } = await import('@aws-sdk/client-dynamodb' as string) as {
+    DynamoDBClient: DynamoDBClientConstructor;
   };
-  const { DynamoDBDocument } = await import('@aws-sdk/lib-dynamodb' as string) as {
-    DynamoDBDocument: DocumentClientConstructor;
+  const { DynamoDBDocumentClient } = await import('@aws-sdk/lib-dynamodb' as string) as {
+    DynamoDBDocumentClient: DocumentClientFromFn;
   };
 
   const clientOptions: Record<string, unknown> = {};
   if (dbConfig.region) clientOptions.region = dbConfig.region;
   if (dbConfig.endpoint) clientOptions.endpoint = dbConfig.endpoint;
 
-  const rawClient = new DynamoDB(clientOptions);
-  return new DynamoDBDocument({ client: rawClient });
+  const rawClient = new DynamoDBClient(clientOptions);
+  return DynamoDBDocumentClient.from(rawClient);
 }
 
 /**

package/src/dynamodb/dynamodb-db.ts

@@ -50,6 +50,24 @@ function generateUlid(): string {
   return id;
 }
 
+/**
+ * Generates a monotonically unique numeric ID for DynamoDB tables with numeric keys.
+ * Uses timestamp-based generation with a sub-millisecond counter to ensure uniqueness.
+ */
+let _numericIdCounter = 0;
+let _numericIdLastMs = 0;
+
+function generateNumericId(): number {
+  const now = Date.now();
+  if (now === _numericIdLastMs) {
+    _numericIdCounter++;
+  } else {
+    _numericIdLastMs = now;
+    _numericIdCounter = 0;
+  }
+  return now * 1000 + _numericIdCounter;
+}
+
 // ---------------------------------------------------------------------------
 // SDK Command factories (injectable for testing without real AWS SDK)
 // ---------------------------------------------------------------------------
@@ -199,6 +217,10 @@ export default class DynamoDBDB {
     return this.client;
   }
 
+  private _resolveTableName(modelName: string): string {
+    return (this.dbConfig.tablePrefix ?? '') + sanitizeTableName(this.deps.getPluralName(modelName));
+  }
+
   /** Resolve Orm singleton — falls back to real import in production. */
   private async _getOrm(): Promise<OrmModule> {
     if (this.deps._importOrm) return this.deps._importOrm();
@@ -235,7 +257,7 @@ export default class DynamoDBDB {
     const rawClient = new DynamoDBClient(clientOptions);
 
     for (const [modelName, schema] of Object.entries(schemas)) {
-      const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+      const tableName = this._resolveTableName(modelName);
       const gsis = this._buildGsiDefinitions(modelName, schema);
 
       try {
@@ -297,6 +319,16 @@ export default class DynamoDBDB {
   // SqlDb contract — persist
   // -------------------------------------------------------------------------
 
+  /**
+   * DynamoDB does NOT use write serialization (#156).
+   *
+   * Unlike MySQL/PostgreSQL, DynamoDB has no server-side foreign key
+   * constraints and no multi-row transactions in standard single-item
+   * operations (PutItem, UpdateItem, DeleteItem). Each operation is
+   * atomic at the item level and cannot deadlock against other items.
+   * Concurrent fire-and-forget writes therefore cannot produce the
+   * cross-row lock contention that causes InnoDB/PG deadlocks.
+   */
   async persist(operation: string, modelName: string, context: PersistContext, response: PersistResponse): Promise<void> {
     const OrmModule = await this._getOrm();
     if (OrmModule.default?.instance?.isView?.(modelName)) return;
@@ -320,7 +352,7 @@ export default class DynamoDBDB {
     const schema = schemas[modelName];
     if (!schema) return undefined;
 
-    const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+    const tableName = this._resolveTableName(modelName);
     const { GetCommand } = await this.deps.loadDocClientCommands();
 
     const params = this.deps.buildGetItem(tableName, { id });
@@ -354,7 +386,7 @@ export default class DynamoDBDB {
     const schema = schemas[modelName];
     if (!schema) return [];
 
-    const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+    const tableName = this._resolveTableName(modelName);
 
     try {
       let items: Record<string, unknown>[];
@@ -421,7 +453,7 @@ export default class DynamoDBDB {
       }
 
       const schema = schemas[modelName];
-      const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+      const tableName = this._resolveTableName(modelName);
 
       try {
         const items = await this._paginatedScan(tableName);
@@ -457,12 +489,13 @@ export default class DynamoDBDB {
     if (!record) return;
 
     const isPendingId = context.rawData?.__pendingSqlId === true;
-    const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+    const tableName = this._resolveTableName(modelName);
 
-    // For numeric-ID models with a pending ID, generate a ULID
+    // For models with a pending ID, generate a unique replacement ID
     let finalId: unknown = record.id;
     if (isPendingId) {
-      finalId = generateUlid();
+      const keyType = this.deps.getDynamoKeyType(schema.idType);
+      finalId = keyType === 'N' ? generateNumericId() : generateUlid();
     }
 
     const item = this._recordToItem(record, schema, context.rawData);
@@ -494,7 +527,7 @@ export default class DynamoDBDB {
     const record = context.record;
     if (!record) return;
 
-    const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+    const tableName = this._resolveTableName(modelName);
     const id = record.id;
     const oldState = context.oldState || {};
     const currentData = record.__data;
@@ -504,7 +537,11 @@ export default class DynamoDBDB {
 
     for (const col of Object.keys(schema.columns)) {
       if (currentData[col] !== oldState[col]) {
-        changedData[col] = currentData[col] ?? null;
+        const value = currentData[col] ?? null;
+        // Date objects must be serialized to ISO-8601 strings for DynamoDB 'S' storage
+        changedData[col] = (value instanceof Date)
+          ? value.toISOString()
+          : value;
       }
     }
 
@@ -535,7 +572,7 @@ export default class DynamoDBDB {
     const id = context.recordId;
     if (id == null) return;
 
-    const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+    const tableName = this._resolveTableName(modelName);
     const { DeleteCommand } = await this.deps.loadDocClientCommands();
     const params = this.deps.buildDeleteItem(tableName, { id });
     await this.requireClient().send(new DeleteCommand(params));
@@ -597,7 +634,7 @@ export default class DynamoDBDB {
     const schemas = this.deps.introspectModels();
 
     for (const [modelName, schema] of Object.entries(schemas)) {
-      const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+      const tableName = this._resolveTableName(modelName);
       const modelGsis = new Map<string, string>();
 
       for (const fkCol of Object.keys(schema.foreignKeys)) {
@@ -659,7 +696,7 @@ export default class DynamoDBDB {
   }
 
   private _buildGsiDefinitions(modelName: string, schema: ModelSchema): unknown[] {
-    const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
+    const tableName = this._resolveTableName(modelName);
     const gsis: unknown[] = [];
 
     for (const fkCol of Object.keys(schema.foreignKeys)) {
@@ -720,7 +757,13 @@ export default class DynamoDBDB {
     if (data.id !== undefined) item.id = data.id;
 
     for (const col of Object.keys(schema.columns)) {
-      if (data[col] !== undefined) item[col] = data[col];
+      if (data[col] !== undefined) {
+        const value = data[col];
+        // Date objects must be serialized to ISO-8601 strings for DynamoDB 'S' storage
+        item[col] = (value instanceof Date)
+          ? value.toISOString()
+          : value;
+      }
     }
 
     for (const fkCol of Object.keys(schema.foreignKeys)) {

package/src/dynamodb/operation-builder.ts

@@ -131,21 +131,27 @@ export function buildScan(
   if (exclusiveStartKey) params.ExclusiveStartKey = exclusiveStartKey;
 
   if (conditions && Object.keys(conditions).length > 0) {
-    const names: Record<string, string> = {};
-    const values: Record<string, unknown> = {};
-    const clauses: string[] = [];
-
-    for (const [attr, val] of Object.entries(conditions)) {
-      const nameAlias = `#${attr}`;
-      const valAlias = `:${attr}`;
-      names[nameAlias] = attr;
-      values[valAlias] = val;
-      clauses.push(`${nameAlias} = ${valAlias}`);
+    const validEntries = Object.entries(conditions).filter(
+      ([, val]) => val !== undefined && val !== null,
+    );
+
+    if (validEntries.length > 0) {
+      const names: Record<string, string> = {};
+      const values: Record<string, unknown> = {};
+      const clauses: string[] = [];
+
+      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;
     }
-
-    params.FilterExpression = clauses.join(' AND ');
-    params.ExpressionAttributeNames = names;
-    params.ExpressionAttributeValues = values;
   }
 
   return params;
@@ -162,11 +168,19 @@ export function buildQuery(
   keyConditions: Record<string, unknown>,
   exclusiveStartKey?: Record<string, unknown>,
 ): QueryParams {
+  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: Record<string, string> = {};
   const values: Record<string, unknown> = {};
   const clauses: string[] = [];
 
-  for (const [attr, val] of Object.entries(keyConditions)) {
+  for (const [attr, val] of validEntries) {
     const nameAlias = `#${attr}`;
     const valAlias = `:${attr}`;
     names[nameAlias] = attr;

package/src/main.ts

@@ -20,7 +20,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';
@@ -177,6 +176,25 @@ export default class Orm {
     }
 
     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));
     }
 

package/src/manage-record.ts

@@ -79,6 +79,28 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
     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);
@@ -86,7 +108,7 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
 
   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
@@ -103,7 +125,7 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
       }
 
       // 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);
@@ -117,15 +139,25 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
   // 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)),
+    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);
+        }
       });
-    });
   }
 
   return record;

package/src/mysql/connection.ts

@@ -9,6 +9,7 @@ interface MysqlConfig {
   connectionLimit?: number;
   migrationsTable?: string;
   migrationsDir?: string;
+  autoMigrate?: boolean;
 }
 
 let pool: Pool | null = null;

package/src/mysql/mysql-db.ts

@@ -84,6 +84,15 @@ export default class MysqlDB {
   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: Promise<void> = Promise.resolve();
+
   constructor(deps: Partial<MysqlDBDeps> = {}) {
     if (MysqlDB.instance) return MysqlDB.instance;
     MysqlDB.instance = this;
@@ -118,7 +127,15 @@ export default class MysqlDB {
     if (pending.length > 0) {
       this.deps.log.db?.(`${pending.length} pending migration(s) found.`);
 
-      const shouldApply = await this.deps.confirm(`${pending.length} pending migration(s) found. Apply now?`);
+      let shouldApply: boolean;
+      if (this.mysqlConfig.autoMigrate === true) {
+        shouldApply = true;
+      } else if (this.mysqlConfig.autoMigrate === false) {
+        shouldApply = false;
+        this.deps.log.warn?.(`autoMigrate is false — skipping ${pending.length} pending migration(s).`);
+      } else {
+        shouldApply = await this.deps.confirm(`${pending.length} pending migration(s) found. Apply now?`);
+      }
 
       if (shouldApply) {
         for (const filename of pending) {
@@ -139,9 +156,17 @@ export default class MysqlDB {
       const modelCount = Object.keys(schemas).length;
 
       if (modelCount > 0) {
-        const shouldGenerate = await this.deps.confirm(
-          `No migrations found but ${modelCount} model(s) detected. Generate and apply initial migration?`
-        );
+        let shouldGenerate: boolean;
+        if (this.mysqlConfig.autoMigrate === true) {
+          shouldGenerate = true;
+        } else if (this.mysqlConfig.autoMigrate === false) {
+          shouldGenerate = false;
+          this.deps.log.warn?.(`autoMigrate is false — skipping initial migration generation for ${modelCount} model(s).`);
+        } else {
+          shouldGenerate = await this.deps.confirm(
+            `No migrations found but ${modelCount} model(s) detected. Generate and apply initial migration?`
+          );
+        }
 
         if (shouldGenerate) {
           const { generateMigration } = await import('./migration-generator.js');
@@ -398,14 +423,21 @@ export default class MysqlDB {
     const Orm = (await import('@stonyx/orm')).default;
     if ((Orm as unknown as { instance?: { isView?: (name: string) => boolean } }).instance?.isView?.(modelName)) return;
 
-    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);
-    }
+    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;
   }
 
   private async _persistCreate(modelName: string, context: PersistContext, response: PersistResponse): Promise<void> {

package/src/orm-request.ts

@@ -10,6 +10,10 @@ import { isOrmRecord } from './utils.js';
 
 interface OrmRequest$ extends Request {
   protocol?: string;
+  // Express sets this to the path the router was mounted at, e.g. '/api/animals'
+  // when orm.restServer.route is '/api'. Optional because non-Express callers
+  // (unit tests, programmatic handler invocation) do not supply it.
+  baseUrl?: string;
   method: string;
   params: { [key: string]: string };
   body?: { [key: string]: unknown };
@@ -77,11 +81,30 @@ function getModelRelationships(modelName: string): { [key: string]: Relationship
   return relationships;
 }
 
-// Helper to build base URL from request
-function getBaseUrl(request: OrmRequest$): string {
+/**
+ * Build the absolute base URL that every advertised link hangs off — origin
+ * plus the prefix the ORM's routes are actually mounted at.
+ *
+ * The prefix is derived from the *request*, not from
+ * `config.orm.restServer.route`. Express sets `request.baseUrl` to the real
+ * mountpath registered by `RestServer.mountRoute`, which for this module is
+ * always `<prefix>/<pluralizedModel>` (see setup-rest-server.ts). Stripping the
+ * trailing model segment therefore yields the prefix by construction, and the
+ * link builder cannot drift from the mount registrar the way a second,
+ * independent normalisation of `route` would.
+ *
+ * When `request.baseUrl` is absent or does not end in the model segment the
+ * prefix is empty, which reproduces the previous origin-only behaviour.
+ */
+function getBaseUrl(request: OrmRequest$, pluralizedModel: string): string {
   const protocol = request.protocol || 'http';
   const host = request.get('host');
-  return `${protocol}://${host}`;
+
+  const modelSegment = `/${pluralizedModel}`;
+  const mountPath = request.baseUrl ?? '';
+  const prefix = mountPath.endsWith(modelSegment) ? mountPath.slice(0, -modelSegment.length) : '';
+
+  return `${protocol}://${host}${prefix}`;
 }
 
 function getId(params: { id?: string; [key: string]: unknown }): string | number {
@@ -278,7 +301,7 @@ export default class OrmRequest extends Request {
       if (accessFilter) recordsToReturn = recordsToReturn.filter(accessFilter as (record: OrmRecord) => boolean);
       if (queryFilterPredicate) recordsToReturn = recordsToReturn.filter(queryFilterPredicate as (record: OrmRecord) => boolean);
 
-      const baseUrl = getBaseUrl(request);
+      const baseUrl = getBaseUrl(request, pluralizedModel);
       const data = recordsToReturn.map(record => record.toJSON?.({ fields: modelFields, baseUrl }));
 
       return buildResponse(data, request.query?.include, recordsToReturn, {
@@ -294,7 +317,7 @@ export default class OrmRequest extends Request {
       const fieldsMap = parseFields(request.query);
       const modelFields = fieldsMap.get(pluralizedModel) || fieldsMap.get(model);
 
-      const baseUrl = getBaseUrl(request);
+      const baseUrl = getBaseUrl(request, pluralizedModel);
       return buildResponse(record.toJSON?.({ fields: modelFields, baseUrl }), request.query?.include, record, {
         links: { self: `${baseUrl}/${pluralizedModel}/${request.params.id}` },
         baseUrl
@@ -376,7 +399,7 @@ export default class OrmRequest extends Request {
     };
 
     const deleteHandler: HandlerFn = ({ params }) => {
-      store.remove(model, getId(params));
+      store.remove(model, getId(params), { _skipAutoPersist: true });
       return 204;
     };
 
@@ -443,9 +466,14 @@ export default class OrmRequest extends Request {
       // Execute main handler
       const response = await handler(request, state);
 
-      // Persist to SQL database for create/update (delete is handled by store.remove auto-persist)
+      // Set context.record for update BEFORE persist so SQL drivers can read it
+      if (operation === 'update' && (response as JsonApiResponse)?.data) {
+        context.record = store.get(this.model, getId(request.params));
+      }
+
+      // Persist to SQL database for all write operations (create/update/delete)
       const sqlDb = Orm.instance.sqlDb;
-      if (sqlDb && (operation === 'create' || operation === 'update')) {
+      if (sqlDb && WRITE_OPERATIONS.has(operation)) {
         await sqlDb.persist(operation, this.model, context, response);
       }
 
@@ -461,8 +489,6 @@ export default class OrmRequest extends Request {
         const responseData = (response as { data: { id: string | number } }).data;
         const recordId = isNaN(responseData.id as unknown as number) ? responseData.id : parseInt(responseData.id as string);
         context.record = store.get(this.model, recordId);
-      } else if (operation === 'update' && (response as JsonApiResponse)?.data) {
-        context.record = store.get(this.model, getId(request.params));
       } else if (operation === 'delete') {
         // For delete, the record may no longer exist, but we have oldState
         context.recordId = getId(request.params);
@@ -499,7 +525,7 @@ export default class OrmRequest extends Request {
         if (!record) return 404;
 
         const relatedData = record.__relationships[relationshipName];
-        const baseUrl = getBaseUrl(request);
+        const baseUrl = getBaseUrl(request, pluralizedModel);
 
         let data: unknown;
         if (info.isArray) {
@@ -523,7 +549,7 @@ export default class OrmRequest extends Request {
         if (!record) return 404;
 
         const relatedData = record.__relationships[relationshipName];
-        const baseUrl = getBaseUrl(request);
+        const baseUrl = getBaseUrl(request, pluralizedModel);
 
         let data: unknown;
         if (info.isArray) {

package/src/postgres/connection.ts

@@ -8,6 +8,7 @@ interface PgConfig {
   password: string;
   database: string;
   connectionLimit: number;
+  [key: string]: unknown;
 }
 
 let pool: PgPool | null = null;
@@ -20,15 +21,18 @@ export async function getPool(pgConfig: PgConfig, extensions: string[] = ['vecto
 
   const { default: pg } = await import('pg');
 
+  const { host, port, user, password, database, connectionLimit, migrationsDir, migrationsTable, autoMigrate, ...poolOpts } = pgConfig;
+
   pool = new pg.Pool({
-    host: pgConfig.host,
-    port: pgConfig.port,
-    user: pgConfig.user,
-    password: pgConfig.password,
-    database: pgConfig.database,
-    max: pgConfig.connectionLimit,
+    host,
+    port,
+    user,
+    password,
+    database,
+    max: connectionLimit,
     idleTimeoutMillis: 30000,
     connectionTimeoutMillis: 10000,
+    ...poolOpts,
   });
 
   // Enable requested PostgreSQL extensions