@azure-net/kit 1.2.6 → 1.3.0

package/dist/core/delivery/injectableDependencies/AsyncHelpers.d.ts

@@ -1,4 +1,4 @@
-import { createErrorParser, type AppError } from './ErrorHandler.js';
+import { type AppError, createErrorParser } from './ErrorHandler.js';
 export interface AsyncActionResponse<T, D = unknown, CustomErrorField = never> {
     success: boolean;
     response: T;
@@ -9,7 +9,7 @@ export declare const createAsyncHelpers: <Custom = unknown>(opts?: {
     parseError?: ReturnType<typeof createErrorParser<Custom>>;
 }) => {
     createAsyncAction: <Res = unknown, Req = unknown>(action: ActionOrThunk<Res>, args?: {
-        beforeSend?: (abort: () => void) => void | Promise<void>;
+        beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;
         onSuccess?: (result: AsyncActionResponse<Res, undefined, Custom>) => Promise<unknown> | unknown;
         onError?: (result: AsyncActionResponse<never, Req, Custom>) => Promise<unknown> | unknown;
         reject?: boolean;
@@ -20,7 +20,7 @@ export declare const createAsyncHelpers: <Custom = unknown>(opts?: {
         fallbackResponse?: Res;
     }) => Promise<AsyncActionResponse<Res, Req, Custom>>;
     createAsyncResource: <Res, Req_1 = unknown>(action: ActionOrThunk<Res>, args?: {
-        beforeSend?: (abort: () => void) => void | Promise<void>;
+        beforeSend?: (next: () => void, abort: () => void) => void | Promise<void>;
         onSuccess?: (result: Res) => Promise<unknown> | unknown;
         onError?: (error: AppError<Req_1, Custom>) => Promise<unknown> | unknown;
         reject?: boolean;

package/dist/core/delivery/injectableDependencies/AsyncHelpers.js

@@ -19,27 +19,28 @@ export const createAsyncHelpers = (opts) => {
             };
         }
         if (args?.beforeSend) {
-            let aborted = false;
-            await Promise.race([
-                Promise.resolve(args.beforeSend(() => {
-                    aborted = true;
-                })),
-                new Promise((_, reject) => {
-                    if (aborted)
-                        reject(new Error('Aborted in beforeSend'));
-                })
-            ]).catch((err) => {
+            const beforeSendResult = await new Promise((resolve) => {
+                const next = () => resolve('next');
+                const abort = () => resolve('abort');
+                Promise.resolve(args.beforeSend(next, abort)).catch((err) => {
+                    console.error('Error in beforeSend:', err);
+                    resolve('abort');
+                });
+            });
+            if (beforeSendResult === 'abort') {
                 const abortError = {
                     type: 'abort',
                     message: 'Aborted in beforeSend',
-                    original: err
+                    original: new Error('Aborted in beforeSend')
                 };
+                if (args?.reject)
+                    throw abortError;
                 return {
                     success: false,
                     error: abortError,
                     response: args?.fallbackResponse
                 };
-            });
+            }
         }
         try {
             const response = await Promise.resolve(typeof action === 'function' ? action() : action);
@@ -64,27 +65,25 @@ export const createAsyncHelpers = (opts) => {
             return args.fallbackResponse;
         }
         if (args?.beforeSend) {
-            let aborted = false;
-            await Promise.race([
-                Promise.resolve(args.beforeSend(() => {
-                    aborted = true;
-                })),
-                new Promise((_, reject) => {
-                    if (aborted)
-                        reject(new Error('Aborted in beforeSend'));
-                })
-            ]).catch((err) => {
-                const abortError = {
-                    type: 'abort',
-                    message: 'Aborted in beforeSend',
-                    original: err
-                };
-                return {
-                    success: false,
-                    error: abortError,
-                    response: args?.fallbackResponse
-                };
+            const beforeSendResult = await new Promise((resolve) => {
+                const next = () => resolve('next');
+                const abort = () => resolve('abort');
+                Promise.resolve(args.beforeSend(next, abort)).catch((err) => {
+                    console.error('Error in beforeSend:', err);
+                    // If beforeSend throws, treat it as abort
+                    resolve('abort');
+                });
             });
+            if (beforeSendResult === 'abort') {
+                if (args?.reject) {
+                    throw {
+                        type: 'abort',
+                        message: 'Aborted in beforeSend',
+                        original: new Error('Aborted in beforeSend')
+                    };
+                }
+                return args.fallbackResponse;
+            }
         }
         try {
             const response = await Promise.resolve(typeof action === 'function' ? action() : action);

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.6",
+  "version": "1.3.0",
   "files": [
     "dist",
     "!dist/**/*.test.*",