@azure-net/kit 1.2.4 → 1.2.6

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

@@ -9,6 +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>;
         onSuccess?: (result: AsyncActionResponse<Res, undefined, Custom>) => Promise<unknown> | unknown;
         onError?: (result: AsyncActionResponse<never, Req, Custom>) => Promise<unknown> | unknown;
         reject?: boolean;
@@ -19,6 +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>;
         onSuccess?: (result: Res) => Promise<unknown> | unknown;
         onError?: (error: AppError<Req_1, Custom>) => Promise<unknown> | unknown;
         reject?: boolean;

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

@@ -18,6 +18,29 @@ export const createAsyncHelpers = (opts) => {
                 response: 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
+                };
+            });
+        }
         try {
             const response = await Promise.resolve(typeof action === 'function' ? action() : action);
             const result = { response, success: true };
@@ -40,6 +63,29 @@ export const createAsyncHelpers = (opts) => {
             args.abort.onAbort?.();
             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
+                };
+            });
+        }
         try {
             const response = await Promise.resolve(typeof action === 'function' ? action() : action);
             await args?.onSuccess?.(response);

package/dist/core/delivery/schema/Schema.d.ts

@@ -31,13 +31,18 @@ interface SchemaBuilder<SchemaData, Rules = unknown, TransformResult = SchemaDat
     with<M extends Record<string, unknown>>(callback: () => M): SchemaBuilder<SchemaData, Rules, TransformResult, M>;
     create(): Schema<SchemaData, TransformResult, CustomMethods>;
 }
-interface SchemaInstance<TransformResult> {
-    json(): TransformResult;
-    formData(): FormData;
-    validated(): boolean;
+interface SchemaInstance<TransformResult, SchemaData> {
+    json(validate?: boolean): TransformResult;
+    formData(validate?: boolean): FormData;
+    validated(): {
+        valid: boolean;
+        errors: RequestErrors<SchemaData>;
+        json(): TransformResult;
+        formData(): FormData;
+    };
 }
 export type Schema<SchemaData, TransformResult, CustomMethods> = CustomMethods & {
-    from(data: Partial<SchemaData> | FormData): SchemaInstance<TransformResult>;
+    from(data: Partial<SchemaData> | FormData): SchemaInstance<TransformResult, SchemaData>;
     getSchemaError(e: unknown): RequestErrors<SchemaData> | undefined;
 };
 export declare const createSchemaFactory: <Rules extends Record<string, unknown>>(rules: Rules) => <SchemaData>() => SchemaBuilder<SchemaData, Rules>;

package/dist/core/delivery/schema/Schema.js

@@ -70,38 +70,44 @@ class SchemaBuilderImpl {
                     throw Error('Data to validate is not an object');
                 }
                 const validated = () => {
-                    if (!rules)
-                        return true;
                     _isValid = true;
                     _errors = {};
-                    const definedSchema = rules(rulesFactory);
-                    for (const key in definedSchema) {
-                        const fieldRules = definedSchema[key] ?? [];
-                        const value = getByPath(key, _preparedData);
-                        for (const rule of fieldRules) {
-                            const failMessage = rule({
-                                val: value,
-                                listValues: _preparedData,
-                                key: key
-                            });
-                            if (failMessage) {
-                                setByPath(_errors, key, failMessage);
-                                _isValid = false;
-                                break;
+                    const definedSchema = rules?.(rulesFactory);
+                    if (definedSchema && typeof definedSchema === 'object' && Object.keys(definedSchema).length) {
+                        for (const key in definedSchema) {
+                            const fieldRules = definedSchema[key] ?? [];
+                            const value = getByPath(key, _preparedData);
+                            for (const rule of fieldRules) {
+                                const failMessage = rule({
+                                    val: value,
+                                    listValues: _preparedData,
+                                    key: key
+                                });
+                                if (failMessage) {
+                                    setByPath(_errors, key, failMessage);
+                                    _isValid = false;
+                                    break;
+                                }
                             }
                         }
                     }
-                    if (!_isValid) {
+                    return {
+                        valid: _isValid,
+                        errors: _errors,
+                        json: () => json(false),
+                        formData: () => formData(false)
+                    };
+                };
+                const json = (validate = true) => {
+                    if (validate && !validated().valid) {
                         throw new SchemaFail(_errors);
                     }
-                    return true;
-                };
-                const json = () => {
-                    validated();
                     return transform(_preparedData);
                 };
-                const formData = () => {
-                    validated();
+                const formData = (validate = true) => {
+                    if (validate && !validated().valid) {
+                        throw new SchemaFail(_errors);
+                    }
                     return FormDataUtil.fromObject(transform(_preparedData));
                 };
                 return {

package/package.json

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