@agravity/public 10.3.4 → 11.0.0

package/api/publicWebAppData.pub.agravity.ts

@@ -10,9 +10,9 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional } from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
-import { CustomHttpParameterCodec } from '../encoder';
+import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
 import { AgravityErrorResponse } from '../model/agravityErrorResponse.pub.agravity';
@@ -50,9 +50,11 @@ export class PublicWebAppDataService extends BaseService {
 
 	/**
 	 * This returns all collections and assets from the given collection type.
+	 * @endpoint get /data/collectiontype/{id}
 	 * @param requestParameters
 	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
 	 * @param reportProgress flag to report request and response progress.
+	 * @param options additional options
 	 */
 	public httpGetDataCollectionType(
 		requestParameters: HttpGetDataCollectionTypeRequestParams,
@@ -116,16 +118,18 @@ export class PublicWebAppDataService extends BaseService {
 			...(withCredentials ? { withCredentials } : {}),
 			headers: localVarHeaders,
 			observe: observe,
-			transferCache: localVarTransferCache,
+			...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
 			reportProgress: reportProgress
 		});
 	}
 
 	/**
 	 * This lists all elements of a given collection which can be used by the web frontend. It includes structure and all assets. All coming live from database.
+	 * @endpoint get /webappdata/{id}
 	 * @param requestParameters
 	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
 	 * @param reportProgress flag to report request and response progress.
+	 * @param options additional options
 	 */
 	public httpGetWebAppData(
 		requestParameters: HttpGetWebAppDataRequestParams,
@@ -189,7 +193,7 @@ export class PublicWebAppDataService extends BaseService {
 			...(withCredentials ? { withCredentials } : {}),
 			headers: localVarHeaders,
 			observe: observe,
-			transferCache: localVarTransferCache,
+			...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
 			reportProgress: reportProgress
 		});
 	}

package/api/publicWorkspaceManagement.pub.agravity.ts

@@ -10,9 +10,9 @@
 /* tslint:disable:no-unused-variable member-ordering */
 
 import { Inject, Injectable, Optional } from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
-import { CustomHttpParameterCodec } from '../encoder';
+import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { OpenApiHttpParams, QueryParamStyle } from '../query.params';
 
 // @ts-ignore
 import { AgravityErrorResponse } from '../model/agravityErrorResponse.pub.agravity';
@@ -54,9 +54,11 @@ export class PublicWorkspaceManagementService extends BaseService {
 
 	/**
 	 * This lists all available workspaces which are stored in the database and not deleted (status \"A\").
+	 * @endpoint get /workspaces
 	 * @param requestParameters
 	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
 	 * @param reportProgress flag to report request and response progress.
+	 * @param options additional options
 	 */
 	public httpWorkspacesGet(
 		requestParameters?: HttpWorkspacesGetRequestParams,
@@ -85,8 +87,9 @@ export class PublicWorkspaceManagementService extends BaseService {
 		const translations = requestParameters?.translations;
 		const acceptLanguage = requestParameters?.acceptLanguage;
 
-		let localVarQueryParameters = new HttpParams({ encoder: this.encoder });
-		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>translations, 'translations');
+		let localVarQueryParameters = new OpenApiHttpParams(this.encoder);
+
+		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, 'translations', <any>translations, QueryParamStyle.Form, true);
 
 		let localVarHeaders = this.defaultHeaders;
 		if (acceptLanguage !== undefined && acceptLanguage !== null) {
@@ -120,21 +123,23 @@ export class PublicWorkspaceManagementService extends BaseService {
 		const { basePath, withCredentials } = this.configuration;
 		return this.httpClient.request<Array<Workspace>>('get', `${basePath}${localVarPath}`, {
 			context: localVarHttpContext,
-			params: localVarQueryParameters,
+			params: localVarQueryParameters.toHttpParams(),
 			responseType: <any>responseType_,
 			...(withCredentials ? { withCredentials } : {}),
 			headers: localVarHeaders,
 			observe: observe,
-			transferCache: localVarTransferCache,
+			...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
 			reportProgress: reportProgress
 		});
 	}
 
 	/**
 	 * Returns one single workspace (from ID).
+	 * @endpoint get /workspaces/{id}
 	 * @param requestParameters
 	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
 	 * @param reportProgress flag to report request and response progress.
+	 * @param options additional options
 	 */
 	public httpWorkspacesGetById(
 		requestParameters: HttpWorkspacesGetByIdRequestParams,
@@ -167,8 +172,9 @@ export class PublicWorkspaceManagementService extends BaseService {
 		const translations = requestParameters?.translations;
 		const acceptLanguage = requestParameters?.acceptLanguage;
 
-		let localVarQueryParameters = new HttpParams({ encoder: this.encoder });
-		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>translations, 'translations');
+		let localVarQueryParameters = new OpenApiHttpParams(this.encoder);
+
+		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, 'translations', <any>translations, QueryParamStyle.Form, true);
 
 		let localVarHeaders = this.defaultHeaders;
 		if (acceptLanguage !== undefined && acceptLanguage !== null) {
@@ -202,12 +208,12 @@ export class PublicWorkspaceManagementService extends BaseService {
 		const { basePath, withCredentials } = this.configuration;
 		return this.httpClient.request<Workspace>('get', `${basePath}${localVarPath}`, {
 			context: localVarHttpContext,
-			params: localVarQueryParameters,
+			params: localVarQueryParameters.toHttpParams(),
 			responseType: <any>responseType_,
 			...(withCredentials ? { withCredentials } : {}),
 			headers: localVarHeaders,
 			observe: observe,
-			transferCache: localVarTransferCache,
+			...(localVarTransferCache !== undefined ? { transferCache: localVarTransferCache } : {}),
 			reportProgress: reportProgress
 		});
 	}

package/api.base.service.ts

@@ -10,6 +10,7 @@
 import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
 import { CustomHttpParameterCodec } from './encoder';
 import { AgravityPublicConfiguration } from './configuration';
+import { OpenApiHttpParams, QueryParamStyle, concatHttpParamsObject } from './query.params';
 
 export class BaseService {
 	protected basePath = 'http://localhost:7072/api';
@@ -37,42 +38,55 @@ export class BaseService {
 		return consumes.indexOf('multipart/form-data') !== -1;
 	}
 
-	protected addToHttpParams(httpParams: HttpParams, value: any, key?: string, isDeep: boolean = false): HttpParams {
-		// If the value is an object (but not a Date), recursively add its keys.
-		if (typeof value === 'object' && !(value instanceof Date)) {
-			return this.addToHttpParamsRecursive(httpParams, value, isDeep ? key : undefined, isDeep);
-		}
-		return this.addToHttpParamsRecursive(httpParams, value, key);
-	}
-
-	protected addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string, isDeep: boolean = false): HttpParams {
+	protected addToHttpParams(httpParams: OpenApiHttpParams, key: string, value: any | null | undefined, paramStyle: QueryParamStyle, explode: boolean): OpenApiHttpParams {
 		if (value === null || value === undefined) {
 			return httpParams;
 		}
-		if (typeof value === 'object') {
-			// If JSON format is preferred, key must be provided.
-			if (key != null) {
-				return isDeep ? Object.keys(value as Record<string, any>).reduce((hp, k) => hp.append(`${key}[${k}]`, value[k]), httpParams) : httpParams.append(key, JSON.stringify(value));
+
+		if (paramStyle === QueryParamStyle.DeepObject) {
+			if (typeof value !== 'object') {
+				throw Error(`An object must be provided for key ${key} as it is a deep object`);
 			}
-			// Otherwise, if it's an array, add each element.
-			if (Array.isArray(value)) {
-				value.forEach((elem) => (httpParams = this.addToHttpParamsRecursive(httpParams, elem, key)));
+
+			return Object.keys(value as Record<string, any>).reduce((hp, k) => hp.append(`${key}[${k}]`, value[k]), httpParams);
+		} else if (paramStyle === QueryParamStyle.Json) {
+			return httpParams.append(key, JSON.stringify(value));
+		} else {
+			// Form-style, SpaceDelimited or PipeDelimited
+
+			if (Object(value) !== value) {
+				// If it is a primitive type, add its string representation
+				return httpParams.append(key, value.toString());
 			} else if (value instanceof Date) {
-				if (key != null) {
-					httpParams = httpParams.append(key, value.toISOString());
+				return httpParams.append(key, value.toISOString());
+			} else if (Array.isArray(value)) {
+				// Otherwise, if it's an array, add each element.
+				if (paramStyle === QueryParamStyle.Form) {
+					return httpParams.set(key, value, { explode: explode, delimiter: ',' });
+				} else if (paramStyle === QueryParamStyle.SpaceDelimited) {
+					return httpParams.set(key, value, { explode: explode, delimiter: ' ' });
 				} else {
-					throw Error('key may not be null if value is Date');
+					// PipeDelimited
+					return httpParams.set(key, value, { explode: explode, delimiter: '|' });
 				}
 			} else {
-				Object.keys(value).forEach((k) => {
-					const paramKey = key ? `${key}.${k}` : k;
-					httpParams = this.addToHttpParamsRecursive(httpParams, value[k], paramKey);
-				});
+				// Otherwise, if it's an object, add each field.
+				if (paramStyle === QueryParamStyle.Form) {
+					if (explode) {
+						Object.keys(value).forEach((k) => {
+							httpParams = this.addToHttpParams(httpParams, k, value[k], paramStyle, explode);
+						});
+						return httpParams;
+					} else {
+						return concatHttpParamsObject(httpParams, key, value, ',');
+					}
+				} else if (paramStyle === QueryParamStyle.SpaceDelimited) {
+					return concatHttpParamsObject(httpParams, key, value, ' ');
+				} else {
+					// PipeDelimited
+					return concatHttpParamsObject(httpParams, key, value, '|');
+				}
 			}
-			return httpParams;
-		} else if (key != null) {
-			return httpParams.append(key, value);
 		}
-		throw Error('key may not be null if value is not object or array');
 	}
 }

package/configuration.ts

@@ -1,5 +1,6 @@
-import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { HttpHeaders, HttpParameterCodec } from '@angular/common/http';
 import { Param } from './param';
+import { OpenApiHttpParams } from './query.params';
 
 export interface AgravityPublicConfigurationParameters {
 	/**
@@ -166,7 +167,7 @@ export class AgravityPublicConfiguration {
 		return value ? headers.set(headerName, (prefix ?? '') + value) : headers;
 	}
 
-	public addCredentialToQuery(credentialKey: string, paramName: string, query: HttpParams): HttpParams {
+	public addCredentialToQuery(credentialKey: string, paramName: string, query: OpenApiHttpParams): OpenApiHttpParams {
 		const value = this.lookupCredential(credentialKey);
 		return value ? query.set(paramName, value) : query;
 	}

package/encoder.ts

@@ -18,3 +18,18 @@ export class CustomHttpParameterCodec implements HttpParameterCodec {
 		return decodeURIComponent(v);
 	}
 }
+
+export class IdentityHttpParameterCodec implements HttpParameterCodec {
+	encodeKey(k: string): string {
+		return k;
+	}
+	encodeValue(v: string): string {
+		return v;
+	}
+	decodeKey(k: string): string {
+		return k;
+	}
+	decodeValue(v: string): string {
+		return v;
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agravity/public",
-	"version": "10.3.4",
+	"version": "11.0.0",
 	"description": "The Agravity GlobalDAM API which allowes API key authenticated access the Agravity GlobalDAM Backend",
 	"author": "Philipp Losbichler",
 	"repository": {
@@ -23,19 +23,19 @@
 		"build": "ng-packagr -p ng-package.json"
 	},
 	"peerDependencies": {
-		"@angular/core": "^19.0.0",
+		"@angular/core": "^21.0.0",
 		"rxjs": "^7.4.0"
 	},
 	"devDependencies": {
-		"@angular/common": "^19.0.0",
-		"@angular/compiler": "^19.0.0",
-		"@angular/compiler-cli": "^19.0.0",
-		"@angular/core": "^19.0.0",
-		"@angular/platform-browser": "^19.0.0",
-		"ng-packagr": "^19.0.0",
+		"@angular/common": "^21.0.0",
+		"@angular/compiler": "^21.0.0",
+		"@angular/compiler-cli": "^21.0.0",
+		"@angular/core": "^21.0.0",
+		"@angular/platform-browser": "^21.0.0",
+		"ng-packagr": "^21.0.0",
 		"reflect-metadata": "^0.1.3",
 		"rxjs": "^7.4.0",
-		"typescript": ">=5.5.0 <5.7.0",
+		"typescript": ">=5.9.0 <6.0.0",
 		"zone.js": "^0.15.0"
 	},
 	"publishConfig": {

package/query.params.ts

@@ -0,0 +1,165 @@
+import { HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { CustomHttpParameterCodec, IdentityHttpParameterCodec } from './encoder';
+
+export enum QueryParamStyle {
+	Json,
+	Form,
+	DeepObject,
+	SpaceDelimited,
+	PipeDelimited
+}
+
+export type Delimiter = ',' | ' ' | '|' | '\t';
+
+export interface ParamOptions {
+	/** When true, serialized as multiple repeated key=value pairs. When false, serialized as a single key with joined values using `delimiter`. */
+	explode?: boolean;
+	/** Delimiter used when explode=false. The delimiter itself is inserted unencoded between encoded values. */
+	delimiter?: Delimiter;
+}
+
+interface ParamEntry {
+	values: string[];
+	options: Required<ParamOptions>;
+}
+
+export class OpenApiHttpParams {
+	private params: Map<string, ParamEntry> = new Map();
+	private defaults: Required<ParamOptions>;
+	private encoder: HttpParameterCodec;
+
+	/**
+	 * @param encoder  Parameter serializer
+	 * @param defaults Global defaults used when a specific parameter has no explicit options.
+	 *                 By OpenAPI default, explode is true for query params with style=form.
+	 */
+	constructor(encoder?: HttpParameterCodec, defaults?: { explode?: boolean; delimiter?: Delimiter }) {
+		this.encoder = encoder || new CustomHttpParameterCodec();
+		this.defaults = {
+			explode: defaults?.explode ?? true,
+			delimiter: defaults?.delimiter ?? ','
+		};
+	}
+
+	private resolveOptions(local?: ParamOptions): Required<ParamOptions> {
+		return {
+			explode: local?.explode ?? this.defaults.explode,
+			delimiter: local?.delimiter ?? this.defaults.delimiter
+		};
+	}
+
+	/**
+	 * Replace the parameter's values and (optionally) its options.
+	 * Options are stored per-parameter (not global).
+	 */
+	set(key: string, values: string[] | string, options?: ParamOptions): this {
+		const arr = Array.isArray(values) ? values.slice() : [values];
+		const opts = this.resolveOptions(options);
+		this.params.set(key, { values: arr, options: opts });
+		return this;
+	}
+
+	/**
+	 * Append a single value to the parameter. If the parameter didn't exist it will be created
+	 * and use resolved options (global defaults merged with any provided options).
+	 */
+	append(key: string, value: string, options?: ParamOptions): this {
+		const entry = this.params.get(key);
+		if (entry) {
+			// If new options provided, override the stored options for subsequent serialization
+			if (options) {
+				entry.options = this.resolveOptions({ ...entry.options, ...options });
+			}
+			entry.values.push(value);
+		} else {
+			this.set(key, [value], options);
+		}
+		return this;
+	}
+
+	/**
+	 * Serialize to a query string according to per-parameter OpenAPI options.
+	 * - If explode=true for that parameter → repeated key=value pairs (each value encoded).
+	 * - If explode=false for that parameter → single key=value where values are individually encoded
+	 *   and joined using the configured delimiter. The delimiter character is inserted AS-IS
+	 *   (not percent-encoded).
+	 */
+	toString(): string {
+		const records = this.toRecord();
+		const parts: string[] = [];
+
+		for (const key in records) {
+			parts.push(`${key}=${records[key]}`);
+		}
+
+		return parts.join('&');
+	}
+
+	/**
+	 * Return parameters as a plain record.
+	 * - If a parameter has exactly one value, returns that value directly.
+	 * - If a parameter has multiple values, returns a readonly array of values.
+	 */
+	toRecord(): Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>> {
+		const parts: Record<string, string | number | boolean | ReadonlyArray<string | number | boolean>> = {};
+
+		for (const [key, entry] of this.params.entries()) {
+			const encodedKey = this.encoder.encodeKey(key);
+
+			if (entry.options.explode) {
+				parts[encodedKey] = entry.values.map((v) => this.encoder.encodeValue(v));
+			} else {
+				const encodedValues = entry.values.map((v) => this.encoder.encodeValue(v));
+
+				// join with the delimiter *unencoded*
+				parts[encodedKey] = encodedValues.join(entry.options.delimiter);
+			}
+		}
+
+		return parts;
+	}
+
+	/**
+	 * Return an Angular's HttpParams with an identity parameter codec as the parameters are already encoded.
+	 */
+	toHttpParams(): HttpParams {
+		const records = this.toRecord();
+
+		let httpParams = new HttpParams({ encoder: new IdentityHttpParameterCodec() });
+
+		return httpParams.appendAll(records);
+	}
+}
+
+export function concatHttpParamsObject(
+	httpParams: OpenApiHttpParams,
+	key: string,
+	item: {
+		[index: string]: any;
+	},
+	delimiter: Delimiter
+): OpenApiHttpParams {
+	let keyAndValues: string[] = [];
+
+	for (const k in item) {
+		keyAndValues.push(k);
+
+		const value = item[k];
+
+		if (Array.isArray(value)) {
+			keyAndValues.push(...value.map(convertToString));
+		} else {
+			keyAndValues.push(convertToString(value));
+		}
+	}
+
+	return httpParams.set(key, keyAndValues, { explode: false, delimiter: delimiter });
+}
+
+function convertToString(value: any): string {
+	if (value instanceof Date) {
+		return value.toISOString();
+	} else {
+		return value.toString();
+	}
+}