@tstdl/base 0.90.88 → 0.90.90

package/authentication/authentication.api.d.ts

@@ -77,7 +77,7 @@ export declare const authenticationApiDefinition: {
             method: "POST";
             parameters: ObjectSchema<{
                 subject: string;
-                data: {};
+                data: import("../types.js").ObjectLiteral;
             }>;
             result: import("../schema/types/types.js").ValueSchema<"ok">;
         };

package/authentication/client/api.client.d.ts

@@ -4,7 +4,7 @@ import type { ObjectSchemaOrType } from '../../schema/types/types.js';
 import type { Record } from '../../types.js';
 import type { AuthenticationApiDefinition } from '../authentication.api.js';
 export declare function getAuthenticationApiClient<AdditionalTokenPayload extends Record, AuthenticationData, AdditionalInitSecretResetData extends Record>(additionalTokenPayloadSchema: ObjectSchemaOrType<AdditionalTokenPayload>, authenticationDataSchema: SchemaTestable<AuthenticationData>, additionalInitSecretResetData: ObjectSchemaOrType<AdditionalInitSecretResetData>): ApiClient<AuthenticationApiDefinition<AdditionalTokenPayload, AuthenticationData, AdditionalInitSecretResetData>>;
-declare const defaultAuthenticationApiClient: ApiClient<AuthenticationApiDefinition<{}, unknown, {}>>;
+declare const defaultAuthenticationApiClient: ApiClient<AuthenticationApiDefinition<import("../../types.js").ObjectLiteral, unknown, import("../../types.js").ObjectLiteral>>;
 export declare class AuthenticationApiClient extends defaultAuthenticationApiClient {
 }
 export {};

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

@@ -1,7 +1,7 @@
 import { EntityRepository } from '../../database/index.js';
 import { afterResolve } from '../../injector/index.js';
 import { equals } from '../../utils/equals.js';
-import { filterUndefinedFromRecord, objectEntries, objectKeys } from '../../utils/object/object.js';
+import { filterUndefinedObjectProperties, objectEntries, objectKeys } from '../../utils/object/object.js';
 import { _throw } from '../../utils/throw.js';
 import { isDefined, isUndefined } from '../../utils/type-guards.js';
 import { MongoBaseRepository } from './mongo-base.repository.js';
@@ -263,7 +263,7 @@ export class MongoEntityRepository extends EntityRepository {
 function normalizeIndex(index) {
     const { name: providedName, unique, v, background, ns, ...indexRest } = index; // eslint-disable-line @typescript-eslint/no-unused-vars
     const name = providedName ?? objectKeys(index.key).join('_');
-    return filterUndefinedFromRecord({ name, unique: (unique == true) ? true : undefined, ...indexRest });
+    return filterUndefinedObjectProperties({ name, unique: (unique == true) ? true : undefined, ...indexRest });
 }
 function convertOptions(options, mappingMap) {
     if (options == undefined) {

package/http/client/http-client-request.d.ts

@@ -1,5 +1,6 @@
 import { type CancellationSignal } from '../../cancellation/index.js';
 import { dispose, type Disposable } from '../../disposable/index.js';
+import type { OneOrMany } from '../../schema/index.js';
 import type { Record, TypedOmit, UndefinableJson, UndefinableJsonObject } from '../../types.js';
 import { HttpForm, type HttpFormObject } from '../http-form.js';
 import { HttpHeaders, type HttpHeadersObject } from '../http-headers.js';
@@ -22,14 +23,17 @@ export type HttpRequestAuthorization = {
     bearer?: string;
     token?: string;
 };
+export type HttpFormDataObjectValue = string | number | boolean | Uint8Array | Blob;
+export type HttpFormDataObject = Record<string, OneOrMany<HttpFormDataObjectValue>>;
 export type HttpClientRequestOptions = Partial<TypedOmit<HttpClientRequest, 'url' | 'method' | 'abortSignal' | 'abort' | 'headers' | 'query' | 'body'>> & {
     urlParameter?: HttpUrlParametersObject | HttpUrlParameters;
     headers?: HttpHeadersObject | HttpHeaders;
     query?: HttpQueryObject | HttpQuery;
     credentials?: HttpRequestCredentials;
     authorization?: HttpRequestAuthorization;
-    body?: TypedOmit<HttpRequestBody, 'form'> & {
+    body?: TypedOmit<HttpRequestBody, 'form' | 'formData'> & {
         form?: HttpFormObject | HttpForm;
+        formData?: HttpFormDataObject | FormData;
     };
     abortSignal?: CancellationSignal;
 };

package/http/client/http-client-request.js

@@ -1,7 +1,8 @@
 import { CancellationToken } from '../../cancellation/index.js';
 import { dispose } from '../../disposable/index.js';
 import { clone } from '../../utils/clone.js';
-import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { objectEntries } from '../../utils/object/object.js';
+import { isArray, isBlob, isDefined, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
 import { HttpForm } from '../http-form.js';
 import { HttpHeaders } from '../http-headers.js';
 import { HttpQuery } from '../http-query.js';
@@ -149,5 +150,28 @@ function normalizeBody(body) {
     if (isDefined(normalizedBody.form)) {
         normalizedBody.form = new HttpForm(normalizedBody.form);
     }
+    if (isDefined(normalizedBody.formData) && !(normalizedBody.formData instanceof FormData)) {
+        const formData = new FormData();
+        for (const [key, value] of objectEntries(normalizedBody.formData)) {
+            if (isArray(value)) {
+                for (const item of value) {
+                    formData.append(key, convertFormDataObjectValue(item));
+                }
+            }
+            else {
+                formData.set(key, convertFormDataObjectValue(value));
+            }
+        }
+        normalizedBody.formData = formData;
+    }
     return normalizedBody;
 }
+function convertFormDataObjectValue(value) {
+    if (isString(value) || isBlob(value)) {
+        return value;
+    }
+    if (isUint8Array(value)) {
+        return new Blob([value]);
+    }
+    return String(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.88",
+  "version": "0.90.90",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/schema/schemas/object.d.ts

@@ -1,7 +1,7 @@
-import type { Record, SimplifiedOptionalize, SimplifyObject, TypedOmit } from '../../types.js';
+import type { ObjectLiteral, Optionalize, Record, SimplifyObject, TypedOmit } from '../../types.js';
 import type { IfNever } from 'type-fest';
-import type { ObjectSchema, ObjectSchemaProperties, TypedObjectSchemaUnknownProperties } from '../types/index.js';
+import { type ObjectSchema, type ObjectSchemaProperties, type TypedObjectSchemaUnknownProperties } from '../types/index.js';
 export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey'>;
 export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<T>;
-export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<SimplifiedOptionalize<T> & IfNever<V, {}, Record<K, V>>>>;
-export declare const emptyObjectSchema: ObjectSchema<{}>;
+export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<Optionalize<T> & IfNever<V, ObjectLiteral, Record<K, V>>>>;
+export declare const emptyObjectSchema: ObjectSchema<ObjectLiteral>;

package/types.d.ts

@@ -103,6 +103,7 @@ export type ReplaceIfUnknown<T, U> = IfUnknown<T, U, T>;
 export type OmitNever<T extends Record> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
+export type BaseType<T extends Exclude<Primitive, null | undefined>> = T extends string ? string : never | T extends number ? number : never | T extends boolean ? boolean : never | T extends bigint ? bigint : never | T extends symbol ? symbol : never;
 export type SharedProperties<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown, I = unknown, J = unknown> = OmitNever<Pick<A & B & C & D & E & F & G & H & I & J, keyof A & keyof B & keyof ReplaceIfUnknown<C, never> & keyof ReplaceIfUnknown<D, never> & keyof ReplaceIfUnknown<E, never> & keyof ReplaceIfUnknown<F, never> & keyof ReplaceIfUnknown<G, never> & keyof ReplaceIfUnknown<H, never> & keyof ReplaceIfUnknown<I, never> & keyof ReplaceIfUnknown<J, never>>>;
 /**
  * Omit properties from a type that extend from a specific type.
@@ -114,7 +115,6 @@ export type OmitBy<T, V> = Omit<T, {
  * Normalize properties of a type that allow `undefined` to make them optional.
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
-export type SimplifiedOptionalize<T extends object> = SimplifyObject<Optionalize<T>>;
 export type Unoptionalize<T extends object> = SimplifyObject<OmitBy<T, undefined> & {
     [P in PropertiesOfType<T, undefined>]: T[P] | undefined;
 }>;

package/utils/object/object.d.ts

@@ -1,5 +1,4 @@
-import type { FromEntries, ObjectLiteral, PickBy, Record, SimplifyObject } from '../../types.js';
-import type { IsEqual } from 'type-fest';
+import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject } from '../../types.js';
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
  * Returns object entries including those with symbols keys (which Object.entries does not)
@@ -19,10 +18,8 @@ export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object:
 export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;
 export declare function filterObjectAsync<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => Promise<boolean>): Promise<Partial<T>>;
-export declare function filterUndefinedFromRecord<T extends Record>(record: T): T extends Record<infer K, infer V> ? Record<K, Exclude<V, undefined>> : never;
-export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): {
-    [P in keyof T]?: IsEqual<T[P], undefined> extends true ? never : Exclude<T[P], undefined>;
-};
+export declare function filterUndefinedFromRecord<K extends PropertyKey, V>(record: Record<K, V>): Record<BaseType<K>, Exclude<V, undefined>>;
+export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>(object: T): SimplifyObject<Optionalize<T>>;
 export declare function copyObjectProperties<T extends ObjectLiteral, U extends T>(source: T, target: U): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: keyof T, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];