@ethlete/query 5.15.0 → 5.16.0

package/.eslintrc.json

@@ -0,0 +1,40 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts"],
+      "extends": ["plugin:@nx/angular", "plugin:@angular-eslint/template/process-inline-templates"],
+      "rules": {
+        "@angular-eslint/directive-selector": [
+          "error",
+          {
+            "type": "attribute",
+            "prefix": "et"
+          }
+        ],
+        "@angular-eslint/component-selector": [
+          "error",
+          {
+            "type": ["element", "attribute"],
+            "prefix": "et",
+            "style": "kebab-case"
+          }
+        ],
+        "@angular-eslint/no-host-metadata-property": "off"
+      }
+    },
+    {
+      "files": ["*.html"],
+      "extends": ["plugin:@nx/angular-template"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": "off"
+      }
+    }
+  ]
+}

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ethlete/query
 
+## 5.16.0
+
+### Minor Changes
+
+- [`3c0cb69`](https://github.com/ethlete-io/ethdk/commit/3c0cb69d3942c1e562905b940b2d75fcb81e77f9) Thanks [@TomTomB](https://github.com/TomTomB)! - Add option to `QueryForm` `resetAllFieldsToDefault` method to skip specific fields by their key
+
+- [`3c0cb69`](https://github.com/ethlete-io/ethdk/commit/3c0cb69d3942c1e562905b940b2d75fcb81e77f9) Thanks [@TomTomB](https://github.com/TomTomB)! - Add `appendDefaultValueToUrl` option to `QueryField`
+
+## 5.15.1
+
+### Patch Changes
+
+- [`69ee325`](https://github.com/ethlete-io/ethdk/commit/69ee32561bf0df78569a1649053a37edf9741b9c) Thanks [@TomTomB](https://github.com/TomTomB)! - Bump only for updating peer deps
+
 ## 5.15.0
 
 ### Minor Changes

package/jest.config.ts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+export default {
+  displayName: 'query',
+  preset: '../../jest.preset.js',
+  setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+  globals: {},
+  coverageDirectory: '../../coverage/libs/query',
+  transform: {
+    '^.+\\.(ts|mjs|js|html)$': [
+      'jest-preset-angular',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+        stringifyContentPathRegex: '\\.(html|svg)$',
+      },
+    ],
+  },
+  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+  snapshotSerializers: [
+    'jest-preset-angular/build/serializers/no-ng-attributes',
+    'jest-preset-angular/build/serializers/ng-snapshot',
+    'jest-preset-angular/build/serializers/html-comment',
+  ],
+};

package/ng-package.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/libs/query",
+  "assets": ["CHANGELOG.md"],
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

@@ -1,30 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "5.15.0",
+  "version": "5.16.0",
   "peerDependencies": {
-    "@angular/common": "18.0.3",
-    "@angular/core": "18.0.3",
-    "@angular/forms": "18.0.3",
-    "@angular/router": "18.0.3",
+    "@angular/common": "18.0.6",
+    "@angular/core": "18.0.6",
+    "@angular/forms": "18.0.6",
+    "@angular/router": "18.0.6",
     "@ethlete/core": "^4.0.3",
     "@ethlete/types": "^1.6.2",
     "rxjs": "^7.8.1"
-  },
-  "module": "fesm2022/ethlete-query.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "esm2022": "./esm2022/ethlete-query.mjs",
-      "esm": "./esm2022/ethlete-query.mjs",
-      "default": "./fesm2022/ethlete-query.mjs"
-    }
-  },
-  "sideEffects": false,
-  "dependencies": {
-    "tslib": "^2.3.0"
   }
-}
+}

package/project.json

@@ -0,0 +1,37 @@
+{
+  "name": "query",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/query/src",
+  "prefix": "et",
+  "tags": [],
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/angular:package",
+      "outputs": ["{workspaceRoot}/dist/{projectRoot}"],
+      "options": {
+        "project": "libs/query/ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "libs/query/tsconfig.lib.prod.json"
+        },
+        "development": {
+          "tsConfig": "libs/query/tsconfig.lib.json"
+        }
+      },
+      "defaultConfiguration": "production"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/query/jest.config.ts"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"]
+    }
+  }
+}

package/{index.d.ts → src/index.ts}

@@ -16,3 +16,5 @@ export * from './lib/query-store';
 export * from './lib/request';
 export * from './lib/symfony';
 export * from './lib/utils';
+
+// Burst cache

package/src/lib/auth/auth-provider.types.ts

@@ -0,0 +1,160 @@
+import { AnyQueryCreator, QueryArgsOf, QueryResponseOf } from '../query-creator';
+
+export interface AuthProvider {
+  /**
+   * The up to date auth header.
+   * This will automatically get injected into every query that has the `secure` property set to `true`.
+   */
+  header: Record<string, string>;
+
+  /**
+   * Cleanup function that gets called once the auth provider gets destroyed.
+   * @internal
+   */
+  cleanUp(): void;
+}
+
+export interface AuthProviderBasicConfig {
+  /**
+   * Basic auth username
+   */
+  username: string;
+
+  /**
+   * Basic auth password
+   */
+  password: string;
+}
+
+export interface AuthProviderCustomHeaderConfig {
+  /**
+   * The custom header name
+   * @example `X-Api-Key`
+   */
+  name: string;
+
+  /**
+   * The custom header value
+   * @example `myApiKey`
+   */
+  value: string;
+}
+
+export interface AuthProviderBearerConfig<T extends AnyQueryCreator> {
+  /**
+   * The initial jwt
+   */
+  token?: string;
+
+  /**
+   * Refresh token configuration
+   */
+  refreshConfig?: BearerRefreshConfig<T>;
+}
+
+export interface BearerRefreshConfig<T extends AnyQueryCreator> {
+  /**
+   * The query used to trade the refresh token for a new token response.
+   */
+  queryCreator: T;
+
+  /**
+   * Determines if the token should be refreshed if **any** query returns a 401 response.
+   * @default true
+   */
+  refreshOnUnauthorizedResponse?: boolean;
+
+  /**
+   * The initial refresh token
+   */
+  token?: string;
+
+  /**
+   * The cookie name where the refresh token is stored
+   */
+  cookieName?: string;
+
+  /**
+   * The domain of the cookie. If not set, the current origin will be used.
+   *
+   * @example
+   * "https://example.com" -> "example.com"
+   * "https://sub.example.com" -> "example.com"
+   */
+  cookieDomain?: string;
+
+  /**
+   * The days until the cookie expires
+   * @default 30
+   */
+  cookieExpiresInDays?: number;
+
+  /**
+   * The path of the cookie
+   * @default '/'
+   */
+  cookiePath?: string;
+
+  /**
+   * Enable or disable the cookie
+   * @default true
+   */
+  cookieEnabled?: boolean;
+
+  /**
+   * The same site property of the cookie
+   * @default 'lax'
+   */
+  cookieSameSite?: 'strict' | 'none' | 'lax';
+
+  /**
+   * The time in milliseconds before the token expires when the refresh should be triggered.
+   * @default 300000 (5 minutes)
+   */
+  refreshBuffer?: number;
+
+  /**
+   * The expires in property name inside the jwt body
+   * @default 'exp'
+   */
+  expiresInPropertyName?: string;
+
+  /**
+   * Determines when the token should be refreshed.
+   * @default AuthBearerRefreshStrategy.BeforeExpiration
+   */
+  strategy?: AuthBearerRefreshStrategy;
+
+  /**
+   * Adapter function used to build the request body for the refresh request.
+   * @default { body: { refreshToken: "refreshToken" } }
+   */
+  requestArgsAdapter?: (tokens: { token: string | null; refreshToken: string }) => QueryArgsOf<T>;
+
+  /**
+   * Adapter function used to extract the token and refreshToken from the response.
+   * @default { token: "token", refreshToken: "refreshToken" }
+   */
+  responseAdapter?: (response: NonNullable<QueryResponseOf<T>>) => TokenResponse;
+}
+
+export const enum AuthBearerRefreshStrategy {
+  /**
+   * Automatically refresh the token 5 minutes before expiration.
+   * The time can be configured with the `refreshBuffer` property.
+   */
+  BeforeExpiration = 'beforeExpiration',
+}
+
+export interface TokenResponse {
+  /**
+   * The access token used inside the authorization http header.
+   */
+  token: string | null;
+
+  /**
+   * The refresh token used for requesting a new token response once the current tokes is expired.
+   * This property is required if the bearer refresh config is set.
+   */
+  refreshToken: string | null;
+}

package/src/lib/auth/auth-provider.utils.ts

@@ -0,0 +1,39 @@
+import { AnyQueryCreator } from '../query-creator';
+import { AuthProvider } from './auth-provider.types';
+import { BasicAuthProvider } from './basic-auth-provider';
+import { BearerAuthProvider } from './bearer-auth-provider';
+import { CustomHeaderAuthProvider } from './custom-header-auth-provider';
+
+export const isBasicAuthProvider = (authProvider: AuthProvider): authProvider is BasicAuthProvider =>
+  authProvider instanceof BasicAuthProvider;
+
+export const isBearerAuthProvider = <T extends AnyQueryCreator>(
+  authProvider: AuthProvider,
+): authProvider is BearerAuthProvider<T> => authProvider instanceof BearerAuthProvider;
+
+export const isCustomHeaderAuthProvider = (authProvider: AuthProvider): authProvider is CustomHeaderAuthProvider =>
+  authProvider instanceof CustomHeaderAuthProvider;
+
+export const decryptBearer = <Result = Record<string, unknown>>(token: string) => {
+  try {
+    const base64Url = token.split('.')[1];
+
+    if (!base64Url) {
+      return null;
+    }
+
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = decodeURIComponent(
+      atob(base64)
+        .split('')
+        .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+        .join(''),
+    );
+
+    return JSON.parse(jsonPayload) as Result;
+  } catch (error) {
+    console.error(`Invalid bearer token: ${token}`, error);
+
+    return null;
+  }
+};

package/src/lib/auth/basic-auth-provider.ts

@@ -0,0 +1,17 @@
+import { AuthProvider, AuthProviderBasicConfig } from './auth-provider.types';
+
+export class BasicAuthProvider implements AuthProvider {
+  get header() {
+    return { Authorization: `Basic ${this._basicAuthString}` };
+  }
+
+  private get _basicAuthString() {
+    return btoa(`${this._config.username}:${this._config.password}`);
+  }
+
+  constructor(public _config: AuthProviderBasicConfig) {}
+
+  cleanUp(): void {
+    // noop
+  }
+}

package/src/lib/auth/bearer-auth-provider.ts

@@ -0,0 +1,243 @@
+import { deleteCookie, getCookie, setCookie } from '@ethlete/core';
+import { BehaviorSubject, Subject, takeUntil, tap, timer } from 'rxjs';
+import {
+  isQueryStateFailure,
+  isQueryStateLoading,
+  isQueryStateSuccess,
+  switchQueryState,
+  takeUntilResponse,
+} from '../query';
+import { AnyQueryCreator, ConstructQuery, QueryResponseOf } from '../query-creator';
+import {
+  AuthBearerRefreshStrategy,
+  AuthProvider,
+  AuthProviderBearerConfig,
+  TokenResponse,
+} from './auth-provider.types';
+import { decryptBearer } from './auth-provider.utils';
+
+export class BearerAuthProvider<T extends AnyQueryCreator> implements AuthProvider {
+  private readonly _destroy$ = new Subject<boolean>();
+  private readonly _currentRefreshQuery$ = new BehaviorSubject<ConstructQuery<T> | null>(null);
+
+  private readonly _tokens$ = new BehaviorSubject<TokenResponse>({
+    token: null,
+    refreshToken: null,
+  });
+
+  get header() {
+    return { Authorization: `Bearer ${this._tokens$.getValue().token}` };
+  }
+
+  get tokens$() {
+    return this._tokens$.asObservable();
+  }
+
+  get tokens() {
+    return this._tokens$.getValue();
+  }
+
+  get currentRefreshQuery$() {
+    return this._currentRefreshQuery$.asObservable();
+  }
+
+  get currentRefreshQuery() {
+    return this._currentRefreshQuery$.getValue();
+  }
+
+  get shouldRefreshOnUnauthorizedResponse() {
+    return (
+      !!this._config.refreshConfig &&
+      (this._config.refreshConfig.refreshOnUnauthorizedResponse === undefined ||
+        this._config.refreshConfig.refreshOnUnauthorizedResponse)
+    );
+  }
+
+  constructor(public _config: AuthProviderBearerConfig<T>) {
+    const cookieEnabled = _config.refreshConfig?.cookieEnabled ?? true;
+    const cookieToken =
+      _config.refreshConfig?.cookieName && cookieEnabled ? getCookie(_config.refreshConfig.cookieName) ?? null : null;
+
+    this._tokens$.next({
+      token: _config.token || null,
+      refreshToken: _config.refreshConfig?.token || cookieToken || null,
+    });
+
+    if (!this.tokens.token && !this.tokens.refreshToken) {
+      if (!_config.refreshConfig?.cookieName) {
+        console.error(
+          'A BearerAuthProvider was created without token or refresh token. You should provide at least a cookieName where the refresh token might be stored.',
+        );
+      }
+
+      return;
+    }
+
+    if (this.tokens.token) {
+      this._prepareForRefresh();
+
+      if (this.tokens.refreshToken && this._config.refreshConfig?.cookieName && cookieEnabled) {
+        this._setCookie();
+      }
+    } else if (this.tokens.refreshToken) {
+      this._refreshQuery();
+    }
+  }
+
+  cleanUp(): void {
+    this._destroy$.next(true);
+    this._destroy$.unsubscribe();
+    this._currentRefreshQuery$.next(null);
+
+    if (this._config.refreshConfig?.cookieName) {
+      this._deleteCookie();
+    }
+  }
+
+  enableCookie() {
+    if (!this._config.refreshConfig?.cookieName) {
+      throw new Error('No cookie name was provided');
+    }
+
+    if (!this.tokens.refreshToken) {
+      throw new Error('No refresh token was provided');
+    }
+
+    this._config.refreshConfig.cookieEnabled = true;
+
+    this._setCookie();
+  }
+
+  disableCookie() {
+    if (!this._config.refreshConfig?.cookieName) {
+      throw new Error('No cookie name was provided');
+    }
+
+    this._config.refreshConfig.cookieEnabled = false;
+
+    this._deleteCookie();
+  }
+
+  private _setCookie() {
+    if (!this._config.refreshConfig?.cookieName || !this.tokens.refreshToken) return;
+
+    setCookie(
+      this._config.refreshConfig.cookieName,
+      this.tokens.refreshToken,
+      this._config.refreshConfig.cookieExpiresInDays,
+      this._config.refreshConfig.cookieDomain,
+      this._config.refreshConfig.cookiePath,
+      this._config.refreshConfig.cookieSameSite,
+    );
+  }
+
+  private _deleteCookie() {
+    if (!this._config.refreshConfig?.cookieName) return;
+
+    deleteCookie(
+      this._config.refreshConfig.cookieName,
+      this._config.refreshConfig.cookiePath,
+      this._config.refreshConfig.cookieDomain,
+    );
+  }
+
+  private _prepareForRefresh() {
+    if (!this.tokens.token || !this._config.refreshConfig) {
+      return;
+    }
+
+    const bearer = decryptBearer(this.tokens.token);
+
+    if (!bearer) {
+      return;
+    }
+
+    const expiresInPropertyName = this._config.refreshConfig.expiresInPropertyName || 'exp';
+    const expiresIn = bearer[expiresInPropertyName] as number | undefined;
+    const fiveMinutes = 5 * 60 * 1000;
+    const refreshBuffer = this._config.refreshConfig.refreshBuffer ?? fiveMinutes;
+
+    if (expiresIn === undefined) {
+      throw new Error(`Bearer token does not contain an '${expiresInPropertyName}' property`);
+    }
+
+    const remainingTime = new Date(expiresIn * 1000).getTime() - refreshBuffer - new Date().getTime();
+
+    const strategy = this._config.refreshConfig.strategy ?? AuthBearerRefreshStrategy.BeforeExpiration;
+
+    switch (strategy) {
+      case AuthBearerRefreshStrategy.BeforeExpiration:
+        timer(remainingTime)
+          .pipe(takeUntil(this._destroy$))
+          .subscribe(() => this._refreshQuery());
+        break;
+    }
+  }
+
+  /**
+   * @internal
+   */
+  _refreshQuery() {
+    const currentQuery = this._currentRefreshQuery$.getValue();
+
+    if (isQueryStateLoading(currentQuery?.rawState)) {
+      return currentQuery;
+    }
+
+    const currentRefreshToken = this.tokens.refreshToken;
+
+    if (!currentRefreshToken || !this._config.refreshConfig) {
+      return;
+    }
+
+    const args = this._config.refreshConfig.requestArgsAdapter?.({
+      token: this.tokens.token,
+      refreshToken: currentRefreshToken,
+    }) ?? {
+      body: { refreshToken: currentRefreshToken },
+    };
+
+    const query = this._config.refreshConfig.queryCreator.prepare(args).execute({ skipCache: true });
+
+    this._currentRefreshQuery$.next(query as ConstructQuery<T>);
+
+    this._currentRefreshQuery$
+      .pipe(
+        switchQueryState(),
+        tap((state) => {
+          if (isQueryStateSuccess(state)) {
+            if (this._config.refreshConfig?.responseAdapter) {
+              const tokens = this._config.refreshConfig.responseAdapter(state.response as QueryResponseOf<T>);
+
+              this._tokens$.next(tokens);
+            } else {
+              this._tokens$.next({
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                token: (state.response as any)['token'],
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                refreshToken: (state.response as any)['refreshToken'],
+              });
+            }
+            const cookieEnabled = this._config.refreshConfig?.cookieEnabled ?? true;
+
+            if (this._config.refreshConfig?.cookieName && this.tokens.refreshToken && cookieEnabled) {
+              this._setCookie();
+            }
+
+            this._prepareForRefresh();
+          } else if (isQueryStateFailure(state)) {
+            this._tokens$.next({ token: null, refreshToken: null });
+
+            if (this._config.refreshConfig?.cookieName) {
+              this._deleteCookie();
+            }
+          }
+        }),
+        takeUntilResponse(),
+        takeUntil(this._destroy$),
+      )
+      .subscribe();
+
+    return query;
+  }
+}

package/src/lib/auth/custom-header-auth-provider.ts

@@ -0,0 +1,13 @@
+import { AuthProvider, AuthProviderCustomHeaderConfig } from './auth-provider.types';
+
+export class CustomHeaderAuthProvider implements AuthProvider {
+  get header() {
+    return { [this._config.name]: this._config.value };
+  }
+
+  constructor(public _config: AuthProviderCustomHeaderConfig) {}
+
+  cleanUp(): void {
+    // noop
+  }
+}

package/{lib/class-validator/class-validator.types.d.ts → src/lib/class-validator/class-validator.types.ts}

@@ -1,6 +1,7 @@
 import { HttpStatusCode } from '../request';
+
 export interface ClassValidatorError {
-    statusCode: HttpStatusCode;
-    message: string[];
-    error: string;
+  statusCode: HttpStatusCode;
+  message: string[];
+  error: string;
 }

package/src/lib/class-validator/class-validator.utils.ts

@@ -0,0 +1,5 @@
+import { ClassValidatorError } from './class-validator.types';
+
+export const isClassValidatorError = (error: unknown): error is ClassValidatorError => {
+  return typeof error === 'object' && error !== null && 'statusCode' in error && 'message' in error && 'error' in error;
+};