@azure-net/kit 1.2.7 → 1.3.1

package/dist/core/infra/httpService/HttpService.d.ts

@@ -1,4 +1,4 @@
-import { type Options } from 'ky';
+import { type Options, type ResponsePromise } from 'ky';
 export interface IHttpServiceResponse<T = unknown> {
     headers: Record<string, string>;
     status: number;
@@ -29,16 +29,31 @@ export declare class HttpServiceError<T> implements IHttpServiceError<T> {
 export interface IHttpServiceOptions extends Options {
     responseFormat?: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
 }
+export interface IHttpServiceInstance {
+    <T>(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise<T>;
+    get<T>(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise<T>;
+    post<T>(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise<T>;
+    put<T>(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise<T>;
+    delete<T>(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise<T>;
+    patch<T>(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise<T>;
+    head(url: string | URL | Request, options?: IHttpServiceOptions): ResponsePromise;
+    create(defaultOptions?: IHttpServiceOptions): IHttpServiceInstance;
+    extend: (defaultOptions: IHttpServiceOptions | ((parentOptions: IHttpServiceOptions) => IHttpServiceOptions)) => IHttpServiceInstance;
+    readonly stop: typeof stop;
+}
 export declare class HttpService {
     private readonly baseUrl;
     private readonly instance;
     private readonly requestHandler?;
     private readonly errorHandler?;
+    private readonly globalErrorHandler?;
     constructor(opts: {
         baseUrl: string;
+        instance?: IHttpServiceInstance;
         baseOptions?: Options;
-        requestHandler?: (options: Options) => void | Promise<void>;
-        errorHandler?: (err: IHttpServiceError) => unknown;
+        onRequest?: (options: Options) => void | Promise<void>;
+        onError?: (err: IHttpServiceError) => HttpServiceError<unknown>;
+        handleError?: (err: unknown) => Promise<HttpServiceError<unknown>>;
     });
     private prepareOptions;
     private prepareResponse;
@@ -48,4 +63,5 @@ export declare class HttpService {
     delete<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
     put<T>(url: string, options?: IHttpServiceOptions): Promise<IHttpServiceResponse<T>>;
     private handleError;
+    private baseErrorHandler;
 }

package/dist/core/infra/httpService/HttpService.js

@@ -34,11 +34,13 @@ export class HttpService {
     instance;
     requestHandler;
     errorHandler;
+    globalErrorHandler;
     constructor(opts) {
         this.baseUrl = opts.baseUrl;
-        this.instance = ky.create(opts?.baseOptions);
-        this.errorHandler = opts?.errorHandler ?? undefined;
-        this.requestHandler = opts?.requestHandler ?? undefined;
+        this.instance = opts.instance ? opts.instance.create(opts?.baseOptions) : ky.create(opts?.baseOptions);
+        this.errorHandler = opts?.onError ?? undefined;
+        this.requestHandler = opts?.onRequest ?? undefined;
+        this.globalErrorHandler = opts?.handleError ?? undefined;
     }
     async prepareOptions(requestOptions) {
         const options = typeof requestOptions === 'object' ? { ...requestOptions } : {};
@@ -132,7 +134,10 @@ export class HttpService {
             throw await this.handleError(error);
         });
     }
-    async handleError(err) {
+    async handleError(error) {
+        return this.globalErrorHandler ? await this.globalErrorHandler(error) : await this.baseErrorHandler(error);
+    }
+    async baseErrorHandler(err) {
         let headers;
         let response;
         try {

package/dist/core/infra/query/QueryBuilder.d.ts

@@ -5,6 +5,7 @@ export interface IQueryBuilder {
         arrayFormat?: ArrayFormat;
         objectFormat?: ObjectFormat;
     }): string;
+    transform(object: object): object;
 }
 export declare class QueryBuilder implements IQueryBuilder {
     private readonly defaultArrayFormat;

package/dist/core/shared/boundaryProvider/Provider.d.ts

@@ -11,9 +11,11 @@ export interface ProviderWithType<T extends ServiceMap> {
 type ProviderFactory<T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>> = (context: {
     [K in keyof D]: InferProviderType<D[K]>;
 }) => T;
-interface LayerProviderOptions<D> {
+export interface ProviderSettings<T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>> {
     dependsOn?: D;
+    boot?: (services: ResolvedServices<T>) => void | Promise<void>;
+    register: ProviderFactory<T, D>;
 }
-export declare const createBoundaryProvider: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, services: ProviderFactory<T, D>, options?: LayerProviderOptions<D>) => ProviderWithType<T>;
+export declare const createBoundaryProvider: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
 export declare function cleanupProvider(name: string): void;
 export {};

package/dist/core/shared/boundaryProvider/Provider.js

@@ -3,6 +3,7 @@ import { EnvironmentUtil } from 'azure-net-tools';
 const clientCache = new Map();
 const factoriesCache = new WeakMap();
 const providerProxyCache = new Map();
+const clientBootFlags = new Map();
 const getProviderCache = (providerName) => {
     if (EnvironmentUtil.isBrowser) {
         if (!clientCache.has(providerName)) {
@@ -26,8 +27,34 @@ const getProviderCache = (providerName) => {
         return providers.get(providerName);
     }
 };
-export const createBoundaryProvider = (name, services, options) => {
-    const { dependsOn = {} } = options ?? {};
+const getBootFlag = (providerName) => {
+    if (EnvironmentUtil.isBrowser) {
+        return clientBootFlags.get(providerName) ?? false;
+    }
+    else {
+        const context = RequestContext.current();
+        if (!context.data.bootFlags) {
+            context.data.bootFlags = new Map();
+        }
+        const bootFlags = context.data.bootFlags;
+        return bootFlags.get(providerName) ?? false;
+    }
+};
+const setBootFlag = (providerName, value) => {
+    if (EnvironmentUtil.isBrowser) {
+        clientBootFlags.set(providerName, value);
+    }
+    else {
+        const context = RequestContext.current();
+        if (!context.data.bootFlags) {
+            context.data.bootFlags = new Map();
+        }
+        const bootFlags = context.data.bootFlags;
+        bootFlags.set(providerName, value);
+    }
+};
+export const createBoundaryProvider = (name, settings) => {
+    const { dependsOn = {}, boot, register } = settings;
     const providerFn = () => {
         if (EnvironmentUtil.isBrowser && providerProxyCache.has(name)) {
             return providerProxyCache.get(name);
@@ -37,8 +64,8 @@ export const createBoundaryProvider = (name, services, options) => {
         const getFactories = () => {
             if (factories)
                 return factories;
-            if (factoriesCache.has(services)) {
-                factories = factoriesCache.get(services);
+            if (factoriesCache.has(register)) {
+                factories = factoriesCache.get(register);
                 return factories;
             }
             const deps = {};
@@ -54,9 +81,9 @@ export const createBoundaryProvider = (name, services, options) => {
                     }
                 });
             }
-            factories = services(deps);
+            factories = register(deps);
             if (EnvironmentUtil.isBrowser) {
-                factoriesCache.set(services, factories);
+                factoriesCache.set(register, factories);
             }
             return factories;
         };
@@ -90,6 +117,14 @@ export const createBoundaryProvider = (name, services, options) => {
         if (EnvironmentUtil.isBrowser) {
             providerProxyCache.set(name, providerProxy);
         }
+        if (boot && !getBootFlag(name)) {
+            setBootFlag(name, true);
+            getFactories();
+            const bootResult = boot(providerProxy);
+            if (bootResult instanceof Promise) {
+                bootResult.catch((err) => console.error(`Error in boot for provider '${name}':`, err));
+            }
+        }
         return providerProxy;
     };
     return providerFn;
@@ -114,6 +149,7 @@ export function cleanupProvider(name) {
             void cleanupCache(cache);
         }
         providerProxyCache.delete(name);
+        clientBootFlags.delete(name);
     }
     else {
         const context = RequestContext.current();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "1.2.7",
+  "version": "1.3.1",
   "files": [
     "dist",
     "!dist/**/*.test.*",