@alauda-fe/common 1.0.0-next.0

package/esm2022/api/crypto.interceptor.mjs

@@ -0,0 +1,186 @@
+import { HttpResponse, } from '@angular/common/http';
+import { Inject, Injectable, isDevMode, Optional } from '@angular/core';
+import aes from 'crypto-js/aes';
+import encBase64 from 'crypto-js/enc-base64';
+import encHex from 'crypto-js/enc-hex';
+import encUtf8 from 'crypto-js/enc-utf8';
+import formatHex from 'crypto-js/format-hex';
+import hmacSha256 from 'crypto-js/hmac-sha256';
+import modeCtr from 'crypto-js/mode-ctr';
+// cspell: disable-next-line
+import noPadding from 'crypto-js/pad-nopadding';
+import { catchError, map, of, tap, throwError } from 'rxjs';
+import { v4 } from 'uuid';
+import { CRYPTO_HEADER_KEY, CRYPTO_KEY, CRYPTO_RANDOM_HEADER_KEY, CRYPTO_TYPE, TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS, } from '../core/constants';
+import { SEARCH_URL_PREFIX } from './k8s-api.service';
+import * as i0 from "@angular/core";
+const defaultEnableUrlRegexps = [
+    /\/api\/v1\/(.*\/)?secrets/i,
+    /\/apis\/platform.tkestack.io\/v1\/clusters(\/.*)?/i,
+    /\/apis\/platform.tkestack.io\/v1\/clustercredentials/i,
+    /\/apis\/platform.tkestack.io\/v1\/machines/i,
+];
+const isStandaloneApi = (url) => {
+    let path = url.match(/((https?:)?\/\/)?[^/]*(\/[^?]*)/)?.[3];
+    if (path && isDevMode()) {
+        // 开发模式下，需要把APIGateway移除
+        // 正常情况不会将前缀设置成多层路径，所以直接移除第一层路径
+        path = path.replace(/^\/[^/]*/, '');
+    }
+    const regex = new RegExp(`^(${SEARCH_URL_PREFIX})?/(apis?|kubernetes)/`);
+    return path && regex.test(path);
+};
+const defaultEnable = (req, extra = []) => {
+    return [...defaultEnableUrlRegexps, ...extra].some(regexp => regexp.test(req.url) && isStandaloneApi(req.url));
+};
+// 可选的 api 加密拦截器，目前仅支持以/api /apis /kubernetes/ 开头的API
+// 后端方案：https://confluence.alauda.cn/pages/viewpage.action?pageId=163054340
+// 如果使用 http 则通过设置 headers 来选择加密策略，key 为 CRYPTO_HEADER_KEY
+// 如果使用 k8sApi 则通过 crypto 来选择加密策略
+// 可以通过 TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS 注入默认的开启加密匹配正则
+export class CryptoInterceptorService {
+    constructor(extraUrlRegexps) {
+        this.extraUrlRegexps = extraUrlRegexps;
+    }
+    factoryContentType(req) {
+        if (!req.headers.has('Content-Type')) {
+            const detectedType = req.detectContentTypeHeader();
+            if (detectedType !== null) {
+                req = req.clone({
+                    headers: req.headers.set('Content-Type', detectedType),
+                });
+            }
+        }
+        return req;
+    }
+    encryptPayload(req) {
+        if (req.headers.get(CRYPTO_HEADER_KEY) && req.body) {
+            let bodyStr = '';
+            // 只对json和字符串类型的payload加密
+            if (typeof req.body === 'string') {
+                bodyStr = req.body;
+            }
+            else {
+                try {
+                    bodyStr = JSON.stringify(req.body);
+                }
+                catch { }
+            }
+            if (bodyStr) {
+                // 将 angular 自动识别的逻辑加到这里来，避免加密后被统一设成 text
+                req = this.factoryContentType(req);
+                const random = v4().replaceAll('-', '');
+                req = req.clone({
+                    headers: req.headers.set(CRYPTO_RANDOM_HEADER_KEY, random),
+                    body: encrypt(bodyStr, random),
+                });
+            }
+        }
+        return req;
+    }
+    factoryReq(req) {
+        if (!req.headers.get(CRYPTO_HEADER_KEY) &&
+            defaultEnable(req, this.extraUrlRegexps)) {
+            req = req.clone({
+                headers: req.headers.set(CRYPTO_HEADER_KEY, CRYPTO_TYPE.Enable),
+            });
+        }
+        req = this.encryptPayload(req);
+        return req;
+    }
+    /**
+     * 实现方案：
+     * 1. 请求和响应处理分开处理，在请求的header上加上加密标识，根据返回的响应header处理对应的加密策略，而不是使用请求时使用的策略。这样能规避服务端的主动加密策略（前端没有使用加密）
+     * 2. 如果解密失败，将不做任何处理，原样返回，因为理论上解密不应该失败，如果失败可能是不需要解密，最主要的是返回解密失败的信息比原样返回对业务来说更没意义
+     */
+    intercept(req, next) {
+        req = this.factoryReq(req);
+        // 当是 progress ，例如 watch 场景的变更，不能获取 responseHeader，所以需要先在其他状态及时记录 responseHeader
+        let responseHeader;
+        return next.handle(req).pipe(tap((event) => {
+            responseHeader = event.headers || responseHeader;
+        }), map(event => {
+            const random = responseHeader?.get(CRYPTO_RANDOM_HEADER_KEY);
+            // 如果不是正常的响应
+            if (!(event instanceof HttpResponse)) {
+                if (event.type === 3 && random) {
+                    const progressEvent = event;
+                    try {
+                        progressEvent.partialText = decrypt(random, progressEvent.partialText);
+                    }
+                    catch { }
+                    return progressEvent;
+                }
+                return event;
+            }
+            // 如果是正常的响应
+            if (!random || !event.body) {
+                return event;
+            }
+            try {
+                return event.clone({
+                    body: decrypt(random, event.body),
+                });
+            }
+            catch { }
+            return event;
+        }), catchError((err) => {
+            // 加密后返回的是字符串，所以如果请求的是json则一定是error的（如果 responseType 是 json，则无论响应的 content-type 是不是 json 都按照json解析）
+            const random = err?.headers?.get(CRYPTO_RANDOM_HEADER_KEY);
+            if (random &&
+                req.responseType === 'json' &&
+                typeof err.error.text === 'string') {
+                try {
+                    // 如果存在加密标识且请求的是json，则这个错误基本上就是因为解析json导致的，所以尝试解密后进行json解析
+                    const json = JSON.parse(decrypt(random, err.error.text));
+                    // 如果解析成功则其就应该是一个正常的返回，所以生成一个正常的 HttpResponse
+                    return of(new HttpResponse({
+                        body: json,
+                        status: err.status,
+                        headers: err.headers,
+                        statusText: err.statusText,
+                        url: err.url,
+                    }));
+                }
+                catch {
+                    return throwError(() => err);
+                }
+            }
+            return throwError(() => err);
+        }));
+    }
+    static { this.ɵfac = function CryptoInterceptorService_Factory(t) { return new (t || CryptoInterceptorService)(i0.ɵɵinject(TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS, 8)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CryptoInterceptorService, factory: CryptoInterceptorService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CryptoInterceptorService, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS]
+            }] }]; }, null); })();
+function decrypt(random, content) {
+    // 先用 hex 把 content 解密
+    const contentHex = encHex.parse(content.replaceAll('\n', ''));
+    // 随机数经过HMAC-sha256后取前端16字节，HMAC密钥为字符串“alauda”
+    const key = encHex.parse(hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32));
+    return aes
+        .decrypt(encBase64.stringify(contentHex), key, {
+        iv: key,
+        mode: modeCtr,
+        padding: noPadding,
+    })
+        .toString(encUtf8);
+}
+function encrypt(content, random) {
+    const key = encHex.parse(hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32));
+    return aes
+        .encrypt(content, key, {
+        iv: key,
+        mode: modeCtr,
+        padding: noPadding,
+    })
+        .toString(formatHex);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.interceptor.js","sourceRoot":"","sources":["../../../../../libs/common/src/api/crypto.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpDownloadProgressEvent,\n  HttpErrorResponse,\n  HttpEvent,\n  HttpHandler,\n  HttpHeaders,\n  HttpInterceptor,\n  HttpRequest,\n  HttpResponse,\n} from '@angular/common/http';\nimport { Inject, Injectable, isDevMode, Optional } from '@angular/core';\nimport aes from 'crypto-js/aes';\nimport encBase64 from 'crypto-js/enc-base64';\nimport encHex from 'crypto-js/enc-hex';\nimport encUtf8 from 'crypto-js/enc-utf8';\nimport formatHex from 'crypto-js/format-hex';\nimport hmacSha256 from 'crypto-js/hmac-sha256';\nimport modeCtr from 'crypto-js/mode-ctr';\n// cspell: disable-next-line\nimport noPadding from 'crypto-js/pad-nopadding';\nimport { catchError, map, Observable, of, tap, throwError } from 'rxjs';\nimport { v4 } from 'uuid';\n\nimport {\n  CRYPTO_HEADER_KEY,\n  CRYPTO_KEY,\n  CRYPTO_RANDOM_HEADER_KEY,\n  CRYPTO_TYPE,\n  TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS,\n} from '../core/constants';\n\nimport { SEARCH_URL_PREFIX } from './k8s-api.service';\n\nconst defaultEnableUrlRegexps: RegExp[] = [\n  /\\/api\\/v1\\/(.*\\/)?secrets/i,\n  /\\/apis\\/platform.tkestack.io\\/v1\\/clusters(\\/.*)?/i,\n  /\\/apis\\/platform.tkestack.io\\/v1\\/clustercredentials/i,\n  /\\/apis\\/platform.tkestack.io\\/v1\\/machines/i,\n];\nconst isStandaloneApi = (url: string) => {\n  let path = url.match(/((https?:)?\\/\\/)?[^/]*(\\/[^?]*)/)?.[3];\n  if (path && isDevMode()) {\n    // 开发模式下，需要把APIGateway移除\n    // 正常情况不会将前缀设置成多层路径，所以直接移除第一层路径\n    path = path.replace(/^\\/[^/]*/, '');\n  }\n  const regex = new RegExp(`^(${SEARCH_URL_PREFIX})?/(apis?|kubernetes)/`);\n  return path && regex.test(path);\n};\nconst defaultEnable = (req: HttpRequest<unknown>, extra: RegExp[] = []) => {\n  return [...defaultEnableUrlRegexps, ...extra].some(\n    regexp => regexp.test(req.url) && isStandaloneApi(req.url),\n  );\n};\n\n// 可选的 api 加密拦截器，目前仅支持以/api /apis /kubernetes/ 开头的API\n// 后端方案：https://confluence.alauda.cn/pages/viewpage.action?pageId=163054340\n// 如果使用 http 则通过设置 headers 来选择加密策略，key 为 CRYPTO_HEADER_KEY\n// 如果使用 k8sApi 则通过 crypto 来选择加密策略\n// 可以通过 TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS 注入默认的开启加密匹配正则\n@Injectable()\nexport class CryptoInterceptorService implements HttpInterceptor {\n  constructor(\n    @Optional()\n    @Inject(TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS)\n    private readonly extraUrlRegexps: RegExp[],\n  ) {}\n\n  private factoryContentType(req: HttpRequest<unknown>) {\n    if (!req.headers.has('Content-Type')) {\n      const detectedType = req.detectContentTypeHeader();\n      if (detectedType !== null) {\n        req = req.clone({\n          headers: req.headers.set('Content-Type', detectedType),\n        });\n      }\n    }\n    return req;\n  }\n\n  private encryptPayload(req: HttpRequest<unknown>) {\n    if (req.headers.get(CRYPTO_HEADER_KEY) && req.body) {\n      let bodyStr = '';\n      // 只对json和字符串类型的payload加密\n      if (typeof req.body === 'string') {\n        bodyStr = req.body;\n      } else {\n        try {\n          bodyStr = JSON.stringify(req.body);\n        } catch {}\n      }\n\n      if (bodyStr) {\n        // 将 angular 自动识别的逻辑加到这里来，避免加密后被统一设成 text\n        req = this.factoryContentType(req);\n\n        const random = v4().replaceAll('-', '');\n        req = req.clone({\n          headers: req.headers.set(CRYPTO_RANDOM_HEADER_KEY, random),\n          body: encrypt(bodyStr, random),\n        });\n      }\n    }\n\n    return req;\n  }\n\n  private factoryReq(req: HttpRequest<unknown>) {\n    if (\n      !req.headers.get(CRYPTO_HEADER_KEY) &&\n      defaultEnable(req, this.extraUrlRegexps)\n    ) {\n      req = req.clone({\n        headers: req.headers.set(CRYPTO_HEADER_KEY, CRYPTO_TYPE.Enable),\n      });\n    }\n\n    req = this.encryptPayload(req);\n\n    return req;\n  }\n\n  /**\n   * 实现方案：\n   * 1. 请求和响应处理分开处理，在请求的header上加上加密标识，根据返回的响应header处理对应的加密策略，而不是使用请求时使用的策略。这样能规避服务端的主动加密策略（前端没有使用加密）\n   * 2. 如果解密失败，将不做任何处理，原样返回，因为理论上解密不应该失败，如果失败可能是不需要解密，最主要的是返回解密失败的信息比原样返回对业务来说更没意义\n   */\n  intercept(\n    req: HttpRequest<unknown>,\n    next: HttpHandler,\n  ): Observable<HttpEvent<unknown>> {\n    req = this.factoryReq(req);\n\n    // 当是 progress ，例如 watch 场景的变更，不能获取 responseHeader，所以需要先在其他状态及时记录 responseHeader\n    let responseHeader: HttpHeaders;\n\n    return next.handle(req).pipe(\n      tap((event: HttpResponse<unknown>) => {\n        responseHeader = event.headers || responseHeader;\n      }),\n      map(event => {\n        const random = responseHeader?.get(CRYPTO_RANDOM_HEADER_KEY);\n        // 如果不是正常的响应\n        if (!(event instanceof HttpResponse)) {\n          if ((event as HttpDownloadProgressEvent).type === 3 && random) {\n            const progressEvent = event as HttpDownloadProgressEvent;\n            try {\n              progressEvent.partialText = decrypt(\n                random,\n                progressEvent.partialText,\n              );\n            } catch {}\n            return progressEvent;\n          }\n          return event;\n        }\n\n        // 如果是正常的响应\n        if (!random || !event.body) {\n          return event;\n        }\n\n        try {\n          return event.clone({\n            body: decrypt(random, event.body as string),\n          });\n        } catch {}\n        return event;\n      }),\n      catchError((err: HttpErrorResponse) => {\n        // 加密后返回的是字符串，所以如果请求的是json则一定是error的（如果 responseType 是 json，则无论响应的 content-type 是不是 json 都按照json解析）\n        const random = err?.headers?.get(CRYPTO_RANDOM_HEADER_KEY);\n        if (\n          random &&\n          req.responseType === 'json' &&\n          typeof err.error.text === 'string'\n        ) {\n          try {\n            // 如果存在加密标识且请求的是json，则这个错误基本上就是因为解析json导致的，所以尝试解密后进行json解析\n            const json = JSON.parse(decrypt(random, err.error.text));\n            // 如果解析成功则其就应该是一个正常的返回，所以生成一个正常的 HttpResponse\n            return of(\n              new HttpResponse({\n                body: json,\n                status: err.status,\n                headers: err.headers,\n                statusText: err.statusText,\n                url: err.url,\n              }),\n            );\n          } catch {\n            return throwError(() => err);\n          }\n        }\n        return throwError(() => err);\n      }),\n    );\n  }\n}\n\nfunction decrypt(random: string, content: string) {\n  // 先用 hex 把 content 解密\n  const contentHex = encHex.parse(content.replaceAll('\\n', ''));\n  // 随机数经过HMAC-sha256后取前端16字节，HMAC密钥为字符串“alauda”\n  const key = encHex.parse(\n    hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32),\n  );\n\n  return aes\n    .decrypt(encBase64.stringify(contentHex), key, {\n      iv: key,\n      mode: modeCtr,\n      padding: noPadding,\n    })\n    .toString(encUtf8);\n}\n\nfunction encrypt(content: string, random: string) {\n  const key = encHex.parse(\n    hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32),\n  );\n\n  return aes\n    .encrypt(content, key, {\n      iv: key,\n      mode: modeCtr,\n      padding: noPadding,\n    })\n    .toString(formatHex);\n}\n"]}

package/esm2022/api/helpers.mjs

@@ -0,0 +1,101 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { ifExist, toKeys } from '../core/utils';
+import { WatchEvent, } from './types';
+export const EMPTY_API_PREFIX_PARTS = {
+    apiGroup: '',
+    apiVersion: '',
+};
+export const getApiPrefixParts = (apiPrefix) => {
+    if (!apiPrefix) {
+        return EMPTY_API_PREFIX_PARTS;
+    }
+    const parts = apiPrefix.split('/');
+    return parts.length > 1
+        ? { apiGroup: parts[0], apiVersion: parts[1] }
+        : { apiGroup: '', apiVersion: parts[0] };
+};
+export const normalizeApiGroup = (apiGroup) => !apiGroup || apiGroup === 'core' ? '' : apiGroup;
+export const normalizeDefinition = (definition) => ({
+    type: definition.type,
+    apiGroup: normalizeApiGroup(definition.apiGroup),
+    apiVersion: definition.apiVersion || 'v1',
+});
+function isDefinition(definition) {
+    return typeof definition === 'object';
+}
+export const createResourceDefinitions = (RESOURCE_DEFINITIONS) => ({
+    RESOURCE_DEFINITIONS,
+    RESOURCE_TYPES: toKeys(RESOURCE_DEFINITIONS),
+    getYamlApiVersion(definition) {
+        if (!isDefinition(definition)) {
+            definition = RESOURCE_DEFINITIONS[definition];
+        }
+        const { apiGroup, apiVersion } = normalizeDefinition(definition);
+        return ((!apiGroup || apiGroup === 'core' ? '' : apiGroup + '/') + apiVersion);
+    },
+});
+export const getMetadataHeaders = (isList, customAccept) => ({
+    Accept: customAccept ||
+        `application/json;as=PartialObjectMetadata${ifExist(isList, 'List')};g=meta.k8s.io;v=v1,application/json`,
+});
+export function reduceWatchEvents(events) {
+    return events.reduce((acc, curr) => {
+        if (!isResourceEvent(curr)) {
+            acc.push(curr);
+            return acc;
+        }
+        const prevIndex = findPrevIndex(acc, curr);
+        if (prevIndex >= 0) {
+            const prev = acc[prevIndex];
+            const nextEventType = calcNextEventType(prev.type, curr.type);
+            acc.splice(prevIndex, 1);
+            acc.push({
+                type: nextEventType,
+                object: curr.object,
+            });
+        }
+        else {
+            acc.push(curr);
+        }
+        return acc;
+    }, []);
+}
+export function isResourceEvent(event) {
+    return event.type !== WatchEvent.Bookmark && event.type !== WatchEvent.Error;
+}
+function findPrevIndex(events, curr) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const prev = events[i];
+        if (isResourceEvent(prev) &&
+            prev.object?.metadata?.uid === curr.object?.metadata?.uid) {
+            return i;
+        }
+    }
+    return -1;
+}
+function calcNextEventType(prev, next) {
+    switch (`${prev} ==> ${next}`) {
+        case `${WatchEvent.Added} ==> ${WatchEvent.Modified}`: {
+            // 下游可能会重复收到 ADDED 事件
+            return WatchEvent.Added;
+        }
+        case `${WatchEvent.Added} ==> ${WatchEvent.Deleted}`: {
+            // 下游可能在未收到 ADDED 事件时直接收到 DELETED 事件
+            return WatchEvent.Deleted;
+        }
+        case `${WatchEvent.Modified} ==> ${WatchEvent.Modified}`: {
+            return WatchEvent.Modified;
+        }
+        case `${WatchEvent.Modified} ==> ${WatchEvent.Deleted}`: {
+            return WatchEvent.Deleted;
+        }
+        default: {
+            console.warn('Unexpected state transition:', `${prev} ==> ${next}`);
+            return next;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../../../libs/common/src/api/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module api\n */\n\nimport { DeepReadonly, Keys, KubernetesResource, ValueOf } from '../core';\nimport { ifExist, toKeys } from '../core/utils';\n\nimport {\n  K8sResourceDefinition,\n  K8sResourceDefinitions,\n  WatchAPIResponse,\n  WatchEvent,\n} from './types';\n\nexport const EMPTY_API_PREFIX_PARTS = {\n  apiGroup: '',\n  apiVersion: '',\n} as const;\n\nexport const getApiPrefixParts = (\n  apiPrefix: string,\n): Omit<Required<K8sResourceDefinition>, 'type'> => {\n  if (!apiPrefix) {\n    return EMPTY_API_PREFIX_PARTS;\n  }\n  const parts: readonly string[] = apiPrefix.split('/');\n  return parts.length > 1\n    ? { apiGroup: parts[0], apiVersion: parts[1] }\n    : { apiGroup: '', apiVersion: parts[0] };\n};\n\nexport const normalizeApiGroup = (apiGroup?: string) =>\n  !apiGroup || apiGroup === 'core' ? '' : apiGroup;\n\nexport const normalizeDefinition = <T extends K8sResourceDefinition>(\n  definition: T,\n): Required<T> =>\n  ({\n    type: definition.type,\n    apiGroup: normalizeApiGroup(definition.apiGroup),\n    apiVersion: definition.apiVersion || 'v1',\n  } as Required<T>);\n\nfunction isDefinition<T extends K8sResourceDefinitions>(\n  definition: keyof T | ValueOf<T>,\n): definition is ValueOf<T> {\n  return typeof definition === 'object';\n}\n\nexport const createResourceDefinitions = <\n  T extends K8sResourceDefinitions,\n  R extends DeepReadonly<{\n    RESOURCE_DEFINITIONS: T;\n    RESOURCE_TYPES: Keys<T>;\n    getYamlApiVersion: (definition: keyof T | ValueOf<T>) => string;\n  }>,\n>(\n  RESOURCE_DEFINITIONS: T,\n): R =>\n  ({\n    RESOURCE_DEFINITIONS,\n    RESOURCE_TYPES: toKeys(RESOURCE_DEFINITIONS),\n    getYamlApiVersion(definition) {\n      if (!isDefinition(definition)) {\n        definition = RESOURCE_DEFINITIONS[definition] as ValueOf<T>;\n      }\n      const { apiGroup, apiVersion } = normalizeDefinition(definition);\n      return (\n        (!apiGroup || apiGroup === 'core' ? '' : apiGroup + '/') + apiVersion\n      );\n    },\n  } as R);\n\nexport const getMetadataHeaders = (\n  isList?: boolean,\n  customAccept?: string,\n) => ({\n  Accept:\n    customAccept ||\n    `application/json;as=PartialObjectMetadata${ifExist(\n      isList,\n      'List',\n    )};g=meta.k8s.io;v=v1,application/json`,\n});\n\nexport function reduceWatchEvents<T extends KubernetesResource>(\n  events: Array<WatchAPIResponse<T>>,\n): Array<WatchAPIResponse<T>> {\n  return events.reduce((acc, curr) => {\n    if (!isResourceEvent(curr)) {\n      acc.push(curr);\n      return acc;\n    }\n\n    const prevIndex = findPrevIndex<T>(acc, curr);\n    if (prevIndex >= 0) {\n      const prev = acc[prevIndex];\n      const nextEventType = calcNextEventType(prev.type, curr.type);\n\n      acc.splice(prevIndex, 1);\n      acc.push({\n        type: nextEventType,\n        object: curr.object,\n      });\n    } else {\n      acc.push(curr);\n    }\n\n    return acc;\n  }, [] as Array<WatchAPIResponse<T>>);\n}\n\nexport function isResourceEvent<T extends KubernetesResource>(\n  event: WatchAPIResponse<T>,\n): boolean {\n  return event.type !== WatchEvent.Bookmark && event.type !== WatchEvent.Error;\n}\n\nfunction findPrevIndex<T extends KubernetesResource>(\n  events: Array<WatchAPIResponse<T>>,\n  curr: WatchAPIResponse<T>,\n) {\n  for (let i = events.length - 1; i >= 0; i--) {\n    const prev = events[i];\n    if (\n      isResourceEvent(prev) &&\n      prev.object?.metadata?.uid === curr.object?.metadata?.uid\n    ) {\n      return i;\n    }\n  }\n\n  return -1;\n}\n\nfunction calcNextEventType(prev: WatchEvent, next: WatchEvent) {\n  switch (`${prev} ==> ${next}`) {\n    case `${WatchEvent.Added} ==> ${WatchEvent.Modified}`: {\n      // 下游可能会重复收到 ADDED 事件\n      return WatchEvent.Added;\n    }\n    case `${WatchEvent.Added} ==> ${WatchEvent.Deleted}`: {\n      // 下游可能在未收到 ADDED 事件时直接收到 DELETED 事件\n      return WatchEvent.Deleted;\n    }\n    case `${WatchEvent.Modified} ==> ${WatchEvent.Modified}`: {\n      return WatchEvent.Modified;\n    }\n    case `${WatchEvent.Modified} ==> ${WatchEvent.Deleted}`: {\n      return WatchEvent.Deleted;\n    }\n    default: {\n      console.warn('Unexpected state transition:', `${prev} ==> ${next}`);\n      return next;\n    }\n  }\n}\n"]}

package/esm2022/api/k8s-api-resource.service.mjs

@@ -0,0 +1,73 @@
+/**
+ * @packageDocumentation
+ * @module api
+ */
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable, isDevMode } from '@angular/core';
+import { map } from 'rxjs';
+import { TOKEN_RESOURCE_DEFINITIONS } from '../core/constants/tokens';
+import { API_GATEWAY, ifExist, publishRef } from '../core/public-api';
+import { EMPTY_API_PREFIX_PARTS, getApiPrefixParts, normalizeApiGroup, normalizeDefinition, } from './helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class K8sApiResourceService {
+    constructor(http, resourceDefinitions) {
+        this.http = http;
+        this.resourceDefinitions = resourceDefinitions;
+        // @internal
+        this._listCaches = {};
+        // @internal
+        this._typeCaches = {};
+    }
+    getDefinition(typeOrDefinition) {
+        if (isDevMode() && !typeOrDefinition) {
+            throw new TypeError(`resource type or definition is required, but received: '${String(typeOrDefinition)}'`);
+        }
+        const definition = typeof typeOrDefinition === 'string'
+            ? this.resourceDefinitions[typeOrDefinition]
+            : typeOrDefinition;
+        if (definition) {
+            return normalizeDefinition(definition);
+        }
+        const type = typeOrDefinition;
+        if (isDevMode()) {
+            console.warn(`"${type}" could not be found in \`TOKEN_RESOURCE_DEFINITIONS\`, have you provided it correctly?`);
+        }
+        return { type, ...EMPTY_API_PREFIX_PARTS };
+    }
+    getApiPath({ cluster, namespace, name, type, apiGroup, apiVersion, }) {
+        apiGroup = normalizeApiGroup(apiGroup);
+        /* eslint-disable sonarjs/no-nested-template-literals */
+        return `${API_GATEWAY}${ifExist(cluster, `/kubernetes/${cluster}`)}/api${apiGroup && 's'}${ifExist(apiGroup, `/${apiGroup}`)}/${apiVersion || 'v1'}${ifExist(namespace, `/namespaces/${namespace}`)}${ifExist(type, `/${type}`)}${ifExist(name, `/${name}`)}`;
+        /* eslint-enable sonarjs/no-nested-template-literals */
+    }
+    getResourceList(resource, cluster) {
+        const { apiVersion } = resource;
+        const cached = this._listCaches[cluster] || (this._listCaches[cluster] = {});
+        return (cached[apiVersion] ||
+            (cached[apiVersion] = this.http
+                .get(this.getApiPath({
+                cluster,
+                ...getApiPrefixParts(apiVersion),
+            }))
+                .pipe(map(({ resources }) => resources), publishRef())));
+    }
+    getResourceType(resource, cluster) {
+        const { apiVersion, kind } = resource;
+        const cached = this._typeCaches[cluster] || (this._typeCaches[cluster] = {});
+        return (cached[apiVersion] ||
+            (cached[apiVersion] = this.getResourceList(resource, cluster).pipe(map(resources => resources.find(item => item.kind === kind).name), publishRef())));
+    }
+    static { this.ɵfac = function K8sApiResourceService_Factory(t) { return new (t || K8sApiResourceService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(TOKEN_RESOURCE_DEFINITIONS)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: K8sApiResourceService, factory: K8sApiResourceService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(K8sApiResourceService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [TOKEN_RESOURCE_DEFINITIONS]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"k8s-api-resource.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/api/k8s-api-resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module api\n */\n\nimport { HttpClient } from '@angular/common/http';\nimport { Inject, Injectable, isDevMode } from '@angular/core';\nimport { Observable, map } from 'rxjs';\n\nimport { APIResourceItem, APIResourceList, KubernetesResource } from '../core';\nimport { TOKEN_RESOURCE_DEFINITIONS } from '../core/constants/tokens';\nimport { API_GATEWAY, ifExist, publishRef } from '../core/public-api';\n\nimport {\n  EMPTY_API_PREFIX_PARTS,\n  getApiPrefixParts,\n  normalizeApiGroup,\n  normalizeDefinition,\n} from './helpers';\nimport { K8sResourceDefinition, K8sResourceDefinitions } from './types';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class K8sApiResourceService {\n  constructor(\n    private readonly http: HttpClient,\n    @Inject(TOKEN_RESOURCE_DEFINITIONS)\n    private readonly resourceDefinitions: K8sResourceDefinitions,\n  ) {}\n\n  // @internal\n  private _listCaches: Record<\n    string,\n    Record<string, Observable<APIResourceItem[]>>\n  > = {};\n\n  // @internal\n  private _typeCaches: Record<string, Record<string, Observable<string>>> = {};\n\n  getDefinition(\n    typeOrDefinition: string | K8sResourceDefinition,\n  ): Required<K8sResourceDefinition> {\n    if (isDevMode() && !typeOrDefinition) {\n      throw new TypeError(\n        `resource type or definition is required, but received: '${String(\n          typeOrDefinition,\n        )}'`,\n      );\n    }\n\n    const definition =\n      typeof typeOrDefinition === 'string'\n        ? this.resourceDefinitions[typeOrDefinition]\n        : typeOrDefinition;\n\n    if (definition) {\n      return normalizeDefinition(definition);\n    }\n\n    const type = typeOrDefinition as string;\n    if (isDevMode()) {\n      console.warn(\n        `\"${type}\" could not be found in \\`TOKEN_RESOURCE_DEFINITIONS\\`, have you provided it correctly?`,\n      );\n    }\n    return { type, ...EMPTY_API_PREFIX_PARTS };\n  }\n\n  getApiPath({\n    cluster,\n    namespace,\n    name,\n    type,\n    apiGroup,\n    apiVersion,\n  }: {\n    cluster?: string;\n    namespace?: string;\n    name?: string;\n    type?: string;\n    apiGroup?: string;\n    apiVersion?: string;\n  }): string {\n    apiGroup = normalizeApiGroup(apiGroup);\n    /* eslint-disable sonarjs/no-nested-template-literals */\n    return `${API_GATEWAY}${ifExist(cluster, `/kubernetes/${cluster}`)}/api${\n      apiGroup && 's'\n    }${ifExist(apiGroup, `/${apiGroup}`)}/${apiVersion || 'v1'}${ifExist(\n      namespace,\n      `/namespaces/${namespace}`,\n    )}${ifExist(type, `/${type}`)}${ifExist(name, `/${name}`)}`;\n    /* eslint-enable sonarjs/no-nested-template-literals */\n  }\n\n  getResourceList<T extends KubernetesResource>(resource: T, cluster: string) {\n    const { apiVersion } = resource;\n\n    const cached =\n      this._listCaches[cluster] || (this._listCaches[cluster] = {});\n\n    return (\n      cached[apiVersion] ||\n      (cached[apiVersion] = this.http\n        .get<APIResourceList>(\n          this.getApiPath({\n            cluster,\n            ...getApiPrefixParts(apiVersion),\n          }),\n        )\n        .pipe(\n          map(({ resources }) => resources),\n          publishRef(),\n        ))\n    );\n  }\n\n  getResourceType<T extends KubernetesResource>(resource: T, cluster: string) {\n    const { apiVersion, kind } = resource;\n\n    const cached =\n      this._typeCaches[cluster] || (this._typeCaches[cluster] = {});\n\n    return (\n      cached[apiVersion] ||\n      (cached[apiVersion] = this.getResourceList(resource, cluster).pipe(\n        map(resources => resources.find(item => item.kind === kind).name),\n        publishRef(),\n      ))\n    );\n  }\n}\n"]}