@tstdl/base 0.88.4 → 0.88.6

package/database/mongo/mongo-base.repository.js

@@ -1,6 +1,6 @@
 import { NotFoundError } from '../../error/not-found.error.js';
 import { objectKeys } from '../../utils/object/object.js';
-import { assertDefined, isNullOrUndefined } from '../../utils/type-guards.js';
+import { assertDefined, isNull, isNullOrUndefined } from '../../utils/type-guards.js';
 import { mongoDocumentFromMaybeNewEntity, toEntity, toMongoDocument, toMongoProjection, toNewEntity, toProjectedEntity } from './model/document.js';
 import { MongoBulk } from './mongo-bulk.js';
 import { replaceOneOperation, updateOneOperation } from './operations.js';
@@ -116,18 +116,18 @@ export class MongoBaseRepository {
     }
     async tryLoadByFilterAndDelete(filter, options) {
         const result = await this.collection.findOneAndDelete(filter, options);
-        if (result.value == undefined) {
+        if (isNull(result)) {
             return undefined;
         }
-        return toEntity(result.value);
+        return toEntity(result);
     }
     async loadByFilterAndUpdate(filter, update, options) {
         const entity = await this.tryLoadByFilterAndUpdate(filter, update, options);
         return throwIfUndefinedElsePass(entity, this.collection.collectionName);
     }
     async tryLoadByFilterAndUpdate(filter, update, options) {
-        const { value: document } = await this.collection.findOneAndUpdate(filter, update, options);
-        if (document == undefined) {
+        const document = await this.collection.findOneAndUpdate(filter, update, options);
+        if (isNull(document)) {
             return undefined;
         }
         return toEntity(document);

package/http/client/http-client.js

@@ -15,7 +15,7 @@ import { encodeUtf8 } from '../../utils/encoding.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
 import { objectEntries } from '../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
-import { isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
+import { isArray, isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
 import { buildUrl } from '../../utils/url-builder.js';
 import { HttpHeaders } from '../http-headers.js';
 import { HttpError, HttpErrorReason } from '../http.error.js';
@@ -284,7 +284,7 @@ function mapParameters(request, baseUrl) {
     if (request.mapParametersToQuery) {
         for (const entry of parameterEntries) {
             const [parameter, value] = entry;
-            if (isUndefined(value) || isObject(value)) {
+            if (isUndefined(value) || (isObject(value) && !isArray(value))) {
                 continue;
             }
             for (const val of toArray(value)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.88.4",
+  "version": "0.88.6",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -120,7 +120,7 @@
     "./utils/string": "./utils/object/index.js"
   },
   "dependencies": {
-    "disposablestack": "^1.1.1",
+    "disposablestack": "^1.1",
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
@@ -159,9 +159,9 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^5.8",
+    "mongodb": "^6.1",
     "nodemailer": "^6.9",
-    "playwright": "^1.37",
+    "playwright": "^1.38",
     "preact": "^10.17",
     "preact-render-to-string": "^6.2",
     "undici": "^5.24",

package/utils/merge.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { assertArray, assertMap, assertObject, assertSet, isArray, isMap, isObject, isSet, isUndefined } from './type-guards.js';
+import { assertArray, assertLiteralObject, assertMap, assertSet, isArray, isLiteralObject, isMap, isSet, isUndefined } from './type-guards.js';
 export function merge(a, b) {
     if (isUndefined(a)) {
         return b;
@@ -7,8 +7,8 @@ export function merge(a, b) {
     if (isUndefined(b)) {
         return a;
     }
-    if (isObject(a)) {
-        assertObject(b, 'Cannot merge object into non-object.');
+    if (isLiteralObject(a)) {
+        assertLiteralObject(b, 'Cannot merge object into non-object.');
         return { ...a, ...b };
     }
     else if (isArray(a)) {

package/utils/type-guards.d.ts

@@ -78,6 +78,12 @@ export declare const assertSymbol: AssertFunction<symbol>;
 export declare const assertNotSymbol: AssertNotFunction<symbol>;
 export declare const assertSymbolPass: AssertPassFunction<symbol>;
 export declare const assertNotSymbolPass: AssertNotPassFunction<symbol>;
+export declare const isLiteralObject: IsFunction<object>;
+export declare const isNotLiteralObject: IsNotFunction<object>;
+export declare const assertLiteralObject: AssertFunction<object>;
+export declare const assertNotLiteralObject: AssertNotFunction<object>;
+export declare const assertLiteralObjectPass: AssertPassFunction<object>;
+export declare const assertNotLiteralObjectPass: AssertNotPassFunction<object>;
 export declare const isObject: IsFunction<object>;
 export declare const isNotObject: IsNotFunction<object>;
 export declare const assertObject: AssertFunction<object>;

package/utils/type-guards.js

@@ -104,7 +104,14 @@ export const assertSymbol = symbolGuards.assertSymbol;
 export const assertNotSymbol = symbolGuards.assertNotSymbol;
 export const assertSymbolPass = symbolGuards.assertSymbolPass;
 export const assertNotSymbolPass = symbolGuards.assertNotSymbolPass;
-const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value != null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
+const literalObjectGuards = createGuards('literal object', (value) => (typeof value == 'object') && (value != null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
+export const isLiteralObject = literalObjectGuards.isLiteralObject;
+export const isNotLiteralObject = literalObjectGuards.isNotLiteralObject;
+export const assertLiteralObject = literalObjectGuards.assertLiteralObject;
+export const assertNotLiteralObject = literalObjectGuards.assertNotLiteralObject;
+export const assertLiteralObjectPass = literalObjectGuards.assertLiteralObjectPass;
+export const assertNotLiteralObjectPass = literalObjectGuards.assertNotLiteralObjectPass;
+const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value != null));
 export const isObject = objectGuards.isObject;
 export const isNotObject = objectGuards.isNotObject;
 export const assertObject = objectGuards.assertObject;