@leancodepl/rx-cqrs-client 7.1.1

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,119 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+var validation = require('@leancodepl/validation');
+var ajax = require('rxjs/ajax');
+
+function handleCommandResponse(handlerFunc) {
+    return (source)=>source.pipe(operators.concatMap((handler)=>{
+            const subj = new rxjs.ReplaySubject();
+            handlerFunc(handler)({
+                reducer: (prev, cur)=>subj.next(cur),
+                initialValue: null
+            });
+            subj.complete();
+            return subj;
+        }));
+}
+
+function authGuard(tokenProvider) {
+    return (response)=>response.pipe(operators.retryWhen((errors$)=>errors$.pipe(operators.mergeMap((error, i)=>{
+                if (i === 0 && error.status === 401) {
+                    return rxjs.from(tokenProvider.invalidateToken()).pipe(operators.mergeMap((success)=>success ? rxjs.of(success) : rxjs.throwError(()=>error)));
+                }
+                return rxjs.throwError(()=>error);
+            }))));
+}
+
+function mkCqrsClient({ cqrsEndpoint, tokenProvider, ajaxOptions }) {
+    return {
+        createQuery (type) {
+            const queryCall = (dto, token)=>ajax.ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/query/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>rxjs.from(tokenProvider.getToken()).pipe(operators.mergeMap((token)=>queryCall(dto, token).pipe(authGuard(tokenProvider))), operators.map(({ response })=>response));
+            }
+            return (dto)=>queryCall(dto).pipe(operators.map(({ response })=>response));
+        },
+        createOperation (type) {
+            const operationCall = (dto, token)=>ajax.ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/operation/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>rxjs.from(tokenProvider.getToken()).pipe(operators.mergeMap((token)=>operationCall(dto, token).pipe(authGuard(tokenProvider))), operators.map(({ response })=>response));
+            }
+            return (dto)=>operationCall(dto).pipe(operators.map(({ response })=>response));
+        },
+        createCommand (type, errorCodesMap) {
+            const commandCall = (dto, token)=>ajax.ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/command/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            function call(dto) {
+                if (tokenProvider) {
+                    return rxjs.from(tokenProvider.getToken()).pipe(operators.mergeMap((token)=>commandCall(dto, token).pipe(authGuard(tokenProvider))), operators.map(({ response })=>response));
+                }
+                return commandCall(dto).pipe(operators.map(({ response })=>response));
+            }
+            call.handle = (dto)=>call(dto).pipe(operators.map((result)=>({
+                        isSuccess: true,
+                        result
+                    })), rxjs.catchError((e)=>{
+                    if (e instanceof ajax.AjaxError && e.status === 422) {
+                        return rxjs.of({
+                            isSuccess: true,
+                            result: e.response
+                        });
+                    }
+                    return rxjs.of({
+                        isSuccess: false,
+                        error: e
+                    });
+                }), operators.map((response)=>validation.handleResponse(response, errorCodesMap)));
+            return call;
+        }
+    };
+}
+
+function reduceBoolean() {
+    return (source)=>source.pipe(rxjs.reduce((prev, cur)=>prev && cur, true));
+}
+
+function reduceObject() {
+    return (source)=>source.pipe(rxjs.reduce((prev, cur)=>({
+                ...prev,
+                ...cur
+            }), {}));
+}
+
+exports.handleCommandResponse = handleCommandResponse;
+exports.mkCqrsClient = mkCqrsClient;
+exports.reduceBoolean = reduceBoolean;
+exports.reduceObject = reduceObject;

package/index.esm.js

@@ -0,0 +1,112 @@
+import { ReplaySubject, from, of, throwError, catchError, reduce } from 'rxjs';
+import { concatMap, retryWhen, mergeMap, map } from 'rxjs/operators';
+import { handleResponse } from '@leancodepl/validation';
+import { AjaxError, ajax } from 'rxjs/ajax';
+
+function handleCommandResponse(handlerFunc) {
+    return (source)=>source.pipe(concatMap((handler)=>{
+            const subj = new ReplaySubject();
+            handlerFunc(handler)({
+                reducer: (prev, cur)=>subj.next(cur),
+                initialValue: null
+            });
+            subj.complete();
+            return subj;
+        }));
+}
+
+function authGuard(tokenProvider) {
+    return (response)=>response.pipe(retryWhen((errors$)=>errors$.pipe(mergeMap((error, i)=>{
+                if (i === 0 && error.status === 401) {
+                    return from(tokenProvider.invalidateToken()).pipe(mergeMap((success)=>success ? of(success) : throwError(()=>error)));
+                }
+                return throwError(()=>error);
+            }))));
+}
+
+function mkCqrsClient({ cqrsEndpoint, tokenProvider, ajaxOptions }) {
+    return {
+        createQuery (type) {
+            const queryCall = (dto, token)=>ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/query/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>from(tokenProvider.getToken()).pipe(mergeMap((token)=>queryCall(dto, token).pipe(authGuard(tokenProvider))), map(({ response })=>response));
+            }
+            return (dto)=>queryCall(dto).pipe(map(({ response })=>response));
+        },
+        createOperation (type) {
+            const operationCall = (dto, token)=>ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/operation/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>from(tokenProvider.getToken()).pipe(mergeMap((token)=>operationCall(dto, token).pipe(authGuard(tokenProvider))), map(({ response })=>response));
+            }
+            return (dto)=>operationCall(dto).pipe(map(({ response })=>response));
+        },
+        createCommand (type, errorCodesMap) {
+            const commandCall = (dto, token)=>ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/command/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            function call(dto) {
+                if (tokenProvider) {
+                    return from(tokenProvider.getToken()).pipe(mergeMap((token)=>commandCall(dto, token).pipe(authGuard(tokenProvider))), map(({ response })=>response));
+                }
+                return commandCall(dto).pipe(map(({ response })=>response));
+            }
+            call.handle = (dto)=>call(dto).pipe(map((result)=>({
+                        isSuccess: true,
+                        result
+                    })), catchError((e)=>{
+                    if (e instanceof AjaxError && e.status === 422) {
+                        return of({
+                            isSuccess: true,
+                            result: e.response
+                        });
+                    }
+                    return of({
+                        isSuccess: false,
+                        error: e
+                    });
+                }), map((response)=>handleResponse(response, errorCodesMap)));
+            return call;
+        }
+    };
+}
+
+function reduceBoolean() {
+    return (source)=>source.pipe(reduce((prev, cur)=>prev && cur, true));
+}
+
+function reduceObject() {
+    return (source)=>source.pipe(reduce((prev, cur)=>({
+                ...prev,
+                ...cur
+            }), {}));
+}
+
+export { handleCommandResponse, mkCqrsClient, reduceBoolean, reduceObject };

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@leancodepl/rx-cqrs-client",
+  "version": "7.1.1",
+  "dependencies": {
+    "@leancodepl/validation": "7.1.0",
+    "rxjs": ">=7.0.0"
+  },
+  "type": "commonjs",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js"
+}

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export { handleCommandResponse } from "./lib/handleCommandResponse";
+export { mkCqrsClient } from "./lib/mkCqrsClient";
+export { reduceBoolean } from "./lib/reduceBoolean";
+export { reduceObject } from "./lib/reduceObject";

package/src/lib/authGuard.d.ts

@@ -0,0 +1,3 @@
+import { TokenProvider } from "@leancodepl/cqrs-client-base";
+import { MonoTypeOperatorFunction } from "rxjs";
+export default function authGuard<T>(tokenProvider: TokenProvider): MonoTypeOperatorFunction<T>;

package/src/lib/handleCommandResponse.d.ts

@@ -0,0 +1,3 @@
+import type { ReducerDescription, ValidationErrorsHandler } from "@leancodepl/validation";
+import { OperatorFunction } from "rxjs";
+export declare function handleCommandResponse<TErrorCodes extends Record<string, number>, THandlerResult>(handlerFunc: (handler: ValidationErrorsHandler<TErrorCodes, never>) => (reducer: ReducerDescription<THandlerResult, any>) => any): OperatorFunction<ValidationErrorsHandler<TErrorCodes, never>, THandlerResult>;

package/src/lib/mkCqrsClient.d.ts

@@ -0,0 +1,19 @@
+import { CommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
+import { AjaxConfig } from "rxjs/ajax";
+export declare function mkCqrsClient({ cqrsEndpoint, tokenProvider, ajaxOptions, }: {
+    cqrsEndpoint: string;
+    tokenProvider?: TokenProvider;
+    ajaxOptions?: Omit<AjaxConfig, "headers" | "url" | "method" | "responseType" | "body">;
+}): {
+    createQuery<TQuery, TResult>(type: string): (dto: TQuery) => import("rxjs").Observable<TResult>;
+    createOperation<TOperation, TResult_1>(type: string): (dto: TOperation) => import("rxjs").Observable<TResult_1>;
+    createCommand<TCommand, TErrorCodes extends {
+        [name: string]: number;
+    }>(type: string, errorCodesMap: TErrorCodes): {
+        (dto: TCommand): import("rxjs").Observable<CommandResult<TErrorCodes>>;
+        handle(dto: TCommand): import("rxjs").Observable<import("@leancodepl/validation").ValidationErrorsHandler<TErrorCodes & {
+            readonly success: -1;
+            readonly failure: -2;
+        }, never>>;
+    };
+};

package/src/lib/reduceBoolean.d.ts

@@ -0,0 +1,2 @@
+import { OperatorFunction } from "rxjs";
+export declare function reduceBoolean(): OperatorFunction<boolean, boolean>;

package/src/lib/reduceObject.d.ts

@@ -0,0 +1,4 @@
+import { OperatorFunction } from "rxjs";
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+export declare function reduceObject<T>(): OperatorFunction<T, Partial<UnionToIntersection<T>>>;
+export {};