@ethlete/query 5.16.0 → 5.16.2

package/lib/symfony/symfony.types.d.ts

@@ -0,0 +1,19 @@
+import { HttpStatusCode } from '../request';
+export interface SymfonyErrorTrace {
+    args: string[];
+    class: string;
+    file: string;
+    function: string;
+    line: number;
+    namespace: string;
+    short_class: string;
+    type: string;
+}
+export interface SymfonyError {
+    class: string;
+    detail: string;
+    status: HttpStatusCode;
+    title: string;
+    trace: SymfonyErrorTrace[];
+    type: string;
+}

package/lib/symfony/symfony.utils.d.ts

@@ -0,0 +1,6 @@
+import { FormViolationListView, FormViolationView } from '@ethlete/types';
+import { SymfonyError } from './symfony.types';
+export declare const isSymfonyError: (error: unknown) => error is SymfonyError;
+export declare const isSymfonyPagerfantaOutOfRangeError: (error: unknown) => error is SymfonyError;
+export declare const isSymfonyFormViolationListError: (error: unknown) => error is FormViolationListView;
+export declare const isSymfonyListError: (error: unknown) => error is FormViolationView[];

package/lib/utils/data.utils.d.ts

@@ -0,0 +1,59 @@
+import { CreateComputedOptions, Signal } from '@angular/core';
+import { ToObservableOptions, ToSignalOptions } from '@angular/core/rxjs-interop';
+import { Observable, Subscribable } from 'rxjs';
+import { AnyQuery, AnyQueryCollection, QueryOf, QueryState } from '../query';
+import { QueryDataOf } from '../query-creator';
+export interface QueryContainerConfig {
+    /**
+     * If `true`, the previous query will be aborted when a new query is pushed into the container.
+     * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+     */
+    abortPrevious?: boolean;
+    /**
+     * If `true`, the query will be aborted when the container is destroyed.
+     * @default true // Only if the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+     */
+    abortOnDestroy?: boolean;
+    /**
+     * If `true`, the previous polling will be stopped when a new query is pushed into the container.
+     * @default true // Only if the query has no other dependents and the request can be cached (GET, OPTIONS, HEAD and GQL_QUERY). Otherwise false.
+     */
+    stopPreviousPolling?: boolean;
+}
+export interface QueryFilterConfig {
+    /**
+     * If `true`, the response will be cached until the next response is received or the query fails.
+     * @default false
+     */
+    cacheResponse?: boolean;
+}
+export declare const addQueryContainerHandling: (obs: Observable<AnyQuery | AnyQuery[] | null>, valueFn: () => AnyQuery | AnyQuery[] | null | undefined, config?: QueryContainerConfig) => void;
+export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>): Signal<T | undefined>;
+export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | undefined>> & {
+    initialValue?: undefined;
+    requireSync?: false;
+} & QueryContainerConfig): Signal<T | undefined>;
+export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | null>> & {
+    initialValue?: null;
+    requireSync?: false;
+} & QueryContainerConfig): Signal<T | null>;
+export declare function toQuerySignal<T extends AnyQuery | null>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T>> & {
+    initialValue?: undefined;
+    requireSync: true;
+} & QueryContainerConfig): Signal<T>;
+export declare function toQuerySignal<T extends AnyQuery | null, const U extends T>(source: Observable<T> | Subscribable<T>, options: NoInfer<ToSignalOptions<T | U>> & {
+    initialValue: U;
+    requireSync?: false;
+} & QueryContainerConfig): Signal<T | U>;
+export declare function queryComputed<T extends AnyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+/**
+ * Creates a signal that will only be reactive until the first query is created.
+ * All subsequent changes inside the computation will be ignored.
+ */
+export declare function queryComputedTillTruthy<T extends AnyQuery | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T | null>;
+export declare function queryArrayComputed<T extends AnyQuery[] | null>(computation: () => T, options?: CreateComputedOptions<T> & QueryContainerConfig & ToObservableOptions): Signal<T>;
+export declare function toQuerySubject<T extends AnyQuery | null>(source: Signal<T>, options?: ToObservableOptions & QueryContainerConfig): Observable<T>;
+export declare function queryStateSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): Signal<QueryState<QueryDataOf<QueryOf<ReturnType<T>>>> | null>;
+export declare function queryStateResponseSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T, options?: QueryFilterConfig): Signal<QueryDataOf<QueryOf<ReturnType<T>>> | null>;
+export declare function queryStateErrorSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T): Signal<import("@ethlete/query").RequestError<unknown> | null>;
+export declare function queryStateLoadingSignal<T extends Signal<AnyQuery | AnyQueryCollection | null>>(source: T): Signal<import("../query").Loading | null>;

package/lib/utils/deep-freeze.util.d.ts

@@ -0,0 +1 @@
+export declare const deepFreeze: <T extends Record<string, unknown>>(object: T) => T;

package/{src/lib/utils/def.util.ts → lib/utils/def.util.d.ts}

@@ -4,4 +4,4 @@
  * @see https://github.com/microsoft/TypeScript/issues/26242
  * @returns null
  */
-export const def = <Data>() => null as unknown as Data;
+export declare const def: <Data>() => Data;

package/package.json

@@ -1,13 +1,30 @@
 {
   "name": "@ethlete/query",
-  "version": "5.16.0",
+  "version": "5.16.2",
   "peerDependencies": {
-    "@angular/common": "18.0.6",
-    "@angular/core": "18.0.6",
-    "@angular/forms": "18.0.6",
-    "@angular/router": "18.0.6",
+    "@angular/common": "^18.1.0",
+    "@angular/core": "^18.1.0",
+    "@angular/forms": "^18.1.0",
+    "@angular/router": "^18.1.0",
     "@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/.eslintrc.json

@@ -1,40 +0,0 @@
-{
-  "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/jest.config.ts

@@ -1,23 +0,0 @@
-/* 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

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

package/project.json

@@ -1,37 +0,0 @@
-{
-  "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/src/lib/auth/auth-provider.types.ts

@@ -1,160 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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
-  }
-}