@avytrix/nestjs-drizzle-crud 3.8.1 → 3.8.2

package/AGENT.md

@@ -151,6 +151,8 @@ Those are legacy manual patterns and they break registration.
 `withCount: false` it skips the count, `total` is `null` and `hasMore` is set.
 `delete` and `softDelete` return a boolean. `update` and `restore` return the entity and
 throw `EntityNotFoundException` when the row is missing.
+Writes turn an ISO string or a number for a date-mode `timestamp` / `date` /
+`datetime` column into a `Date`; a value that is not a date is a 400 naming the column.
 
 Every method takes `options`: `{ transaction, relations, select, search, hooks, lock, forNoKeyUpdate, withDeleted, onlyDeleted, skipAllowlists, bulkMode, counts, context, skipScope, skipEvents, expectedVersion, expectedVersions }`.
 

package/CHANGELOG.md

@@ -11,6 +11,58 @@ restore, `ER_DUP_ENTRY` mapping, dialect locking) are tracked separately and unc
 3.3.1, 3.4.0, 3.5.0 and 3.5.2 were tagged but never published to npm. Their changes reached npm
 in 3.5.1 (3.3.1 to 3.5.0) and 3.6.0 (3.5.2). The unscoped `nestjs-drizzle-crud` stops at 3.3.0.
 
+## [3.8.2] - 2026-11-04
+
+Fixes from the 3.8.1 audit (G-01 to G-08). The tenant key check now lets the database compare keys,
+so it follows each column's collation, and a malformed key or an ISO date string in a write body is
+no longer a 500. No public API or override point changed, and no operation sends more statements
+than in 3.8.1.
+
+### Changed
+
+- The tenant key check, `attach` and `sync` leave the key comparison to the database. They join the
+  keys they were sent, as an inline `VALUES` list, against the related table in the same scoped
+  `SELECT`, so the column's type and collation decide which key matched. A `citext` or SQLite
+  `NOCASE` key of the caller's own tenant in another case is accepted again (3.8.1 refused it with
+  a 400), and on MySQL a key under a `_bin` collation that differs from another tenant's only in
+  case is refused. PostgreSQL `text` still compares exactly, and a uuid matches in any case. On
+  MySQL an integer or decimal key is compared in its column's type, so a `BIGINT` past 2^53 is
+  matched exactly. `attach` and `sync` link each target by its key as stored, so `"ann@x.io"` and
+  `"Ann@X.io"` on a `citext` column give one link.
+- `massUpdate` and `massUpsert` load `relations` and `counts` inside their transaction when a value
+  holds a Drizzle `sql` expression. A load that fails then rolls the write back, so a retry no
+  longer adds `views + 1` twice.
+- A `RangeError` thrown while a statement's values are mapped (a custom type's own check, say) is
+  no longer reported as "Too many values in one statement". Only the call stack overflow of an
+  oversized parameter list is.
+
+### Fixed
+
+- A belongs-to key the column's type cannot hold (`"nope"` for a uuid) is a 400 in `massCreate`,
+  `massUpdate` and `massUpsert`, and in `update` inside a caller's transaction. It was a raw
+  `22P02` or `25P02`, a 500.
+- Every write (`create`, `update`, `upsert`, the mass writes and nested rows) turns an ISO date
+  string or a number for a date-mode `timestamp`, `date` or `datetime` column into a `Date`, as
+  filters already did. It was a 500 `TypeError` (`value.toISOString is not a function`). A value
+  that is not a date, an Invalid Date included, is a 400 that names the column, in a write and in a
+  filter.
+- `massUpdate` groups SETs by their raw values: a hook that returns `null` for one id and an
+  Invalid Date for another no longer gets both into one `UPDATE`. A `Date` and its ISO string are
+  two values, and byte arrays compare by their bytes.
+- A `massUpdate` whose SETs all hold the same `sql` expression object, as in
+  ``massUpdate(ids, { n: sql`n + 1` })``, sends one `UPDATE` instead of one per id.
+- The per-call scope memo ends with the public call that started it. Options a hook kept and passed
+  to a later call reused the old memo, which grew with each call and resolved a context object
+  mutated in place to its old tenant.
+
+### Docs
+
+- The 3.8.1 entry now says the 404 ahead of a refused value holds outside a caller's transaction,
+  and that a mass write with an SQL value was not safe to retry. The bulk operations page says when
+  such a write loads its relations and that one shared `sql` object is one `UPDATE`.
+- The multi-tenancy page says the database compares the keys. The CRUD operations page, the README
+  and `AGENT.md` say date strings are parsed on writes.
+
 ## [3.8.1] - 2026-11-04
 
 Fixes from the 3.8.0 audit (D-01 to D-11). Three of them close gaps in tenant isolation: a scope
@@ -34,10 +86,13 @@ and nested children that skipped the key check. No public API or override point
   write is a 404 entry and the batch writes nothing, instead of being stamped again or
   hard-deleted. `massForceDelete` still removes a row in either state.
 - `massCreate` loads `relations` and `counts` inside its transaction again. A load that fails
-  rolls the rows back, so a retry no longer stores them twice. The other mass writes, which give
-  the same rows when retried, still load after the commit.
+  rolls the rows back, so a retry no longer stores them twice. The other mass writes still load
+  after the commit, where a retry gives the same rows, except for a write whose values hold an SQL
+  expression (``massUpdate(ids, { views: sql`views + 1` })``), which 3.8.2 loads inside too.
 - `update` of a missing row with a value the database refuses (`update(999, { views: "abc" })`)
-  is a 404, as it was before 3.8.0, instead of a 400.
+  is a 404, as it was before 3.8.0, instead of a 400, outside a caller's transaction. Inside one
+  (`options.transaction`) the failed statement has aborted the transaction on PostgreSQL, so the
+  answer stays the 400, which is the same for every tenant.
 
 ### Fixed
 

package/README.md

@@ -445,6 +445,10 @@ export class UsersService extends SqlBaseCrudService<User, CreateUserDto, Update
 | `detach(id, relation, ids?, options?)` | `Promise<T>` | Unlink some, or all when `ids` is left out. |
 | `sync(id, relation, ids, options?)` | `Promise<T>` | Make the links exactly `ids`. |
 
+Every write turns an ISO string or a number for a date-mode `timestamp`, `date`
+or `datetime` column into a `Date`, so a JSON body needs no transforming DTO for
+it. A value that is not a date is a 400 that names the column.
+
 ### Bulk (run inside a transaction)
 
 | Method | Returns |

package/dist/core/abstract/sql-base-crud.service.d.ts

@@ -21,12 +21,15 @@ export declare abstract class SqlBaseCrudService<T extends Record<string, any>,
     protected primaryKeyOf(table: any): string;
     protected isTextColumn(column: any): boolean;
     protected coerceFilterValue(column: any, value: any): any;
+    private toDate;
+    private coerceDates;
     private static readonly ALLOWLIST_LABELS;
     protected assertAllowed(list: keyof CrudAllowlists, path: string, options?: SqlOperationOptions): void;
     protected checkReadOptions(options?: SqlOperationOptions): void;
     protected rowScope(options?: SqlOperationOptions): any[];
     protected resolveScope(options?: SqlOperationOptions): CrudScopeValues | null;
     private withScopeMemo;
+    private scopedCall;
     private checkScope;
     protected scopeConditions(options?: SqlOperationOptions, table?: any): any[];
     protected relatedRowScope(target: any, options?: SqlOperationOptions): any[];
@@ -186,7 +189,11 @@ export declare abstract class SqlBaseCrudService<T extends Record<string, any>,
     sync(id: any, relation: string, relatedIds: unknown[], options?: SqlOperationOptions): Promise<T>;
     private changeLinks;
     private valueKey;
-    private uniqueValues;
+    private distinct;
+    private matchKeys;
+    private keyInput;
+    private mysqlKeyCast;
+    private pgKeyType;
     private tableName;
     protected prepareUpdate(data: UpdateDto, options?: SqlOperationOptions): Record<string, any>;
     update(id: any, data: UpdateDto, options?: SqlOperationOptions): Promise<T>;
@@ -219,6 +226,7 @@ export declare abstract class SqlBaseCrudService<T extends Record<string, any>,
     massRestore(ids: any[], options?: SqlOperationOptions): Promise<T[]>;
     massDelete(ids: any[], options?: SqlOperationOptions): Promise<boolean>;
     massForceDelete(ids: any[], options?: SqlOperationOptions): Promise<boolean>;
+    private holdsSql;
     private uniqueIds;
     private fingerprint;
     private assertAllExist;