@nx/angular 19.1.0-beta.1 → 19.1.0-beta.2

package/src/runtime/nx/data-persistence.js

@@ -1,350 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.navigation = exports.fetch = exports.optimisticUpdate = exports.pessimisticUpdate = void 0;
-const router_store_1 = require("@ngrx/router-store");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-/**
- *
- * @whatItDoes Handles pessimistic updates (updating the server first).
- *
- * Updating the server, when implemented naively, suffers from race conditions and poor error handling.
- *
- * `pessimisticUpdate` addresses these problems. It runs all fetches in order, which removes race conditions
- * and forces the developer to handle errors.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('UPDATE_TODO'),
- *       pessimisticUpdate({
- *         // provides an action
- *         run: (action: UpdateTodo) => {
- *           // update the backend first, and then dispatch an action that will
- *           // update the client side
- *           return this.backend.updateTodo(action.todo.id, action.todo).pipe(
- *             map((updated) => ({
- *               type: 'UPDATE_TODO_SUCCESS',
- *               todo: updated,
- *             }))
- *           );
- *         },
- *         onError: (action: UpdateTodo, error: any) => {
- *           // we don't need to undo the changes on the client side.
- *           // we can dispatch an error, or simply log the error here and return `null`
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * Note that if you don't return a new action from the run callback, you must set the dispatch property
- * of the effect to false, like this:
- *
- * ```typescript
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       //...
- *     ), { dispatch: false }
- *   );
- * }
- * ```
- *
- * @param opts
- */
-function pessimisticUpdate(opts) {
-    return (source) => {
-        return source.pipe(mapActionAndState(), (0, operators_1.concatMap)(runWithErrorHandling(opts.run, opts.onError)));
-    };
-}
-exports.pessimisticUpdate = pessimisticUpdate;
-/**
- *
- * @whatItDoes Handles optimistic updates (updating the client first).
- *
- * It runs all fetches in order, which removes race conditions and forces the developer to handle errors.
- *
- * When using `optimisticUpdate`, in case of a failure, the developer has already updated the state locally,
- * so the developer must provide an undo action.
- *
- * The error handling must be done in the callback, or by means of the undo action.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('UPDATE_TODO'),
- *       optimisticUpdate({
- *         // provides an action
- *         run: (action: UpdateTodo) => {
- *           return this.backend.updateTodo(action.todo.id, action.todo).pipe(
- *             mapTo({
- *               type: 'UPDATE_TODO_SUCCESS',
- *             })
- *           );
- *         },
- *         undoAction: (action: UpdateTodo, error: any) => {
- *           // dispatch an undo action to undo the changes in the client state
- *           return {
- *             type: 'UNDO_TODO_UPDATE',
- *             todo: action.todo,
- *           };
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * Note that if you don't return a new action from the run callback, you must set the dispatch property
- * of the effect to false, like this:
- *
- * ```typescript
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       //...
- *     ), { dispatch: false }
- *   );
- * }
- * ```
- *
- * @param opts
- */
-function optimisticUpdate(opts) {
-    return (source) => {
-        return source.pipe(mapActionAndState(), (0, operators_1.concatMap)(runWithErrorHandling(opts.run, opts.undoAction)));
-    };
-}
-exports.optimisticUpdate = optimisticUpdate;
-/**
- *
- * @whatItDoes Handles data fetching.
- *
- * Data fetching implemented naively suffers from race conditions and poor error handling.
- *
- * `fetch` addresses these problems. It runs all fetches in order, which removes race conditions
- * and forces the developer to handle errors.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   loadTodos$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('GET_TODOS'),
- *       fetch({
- *         // provides an action
- *         run: (a: GetTodos) => {
- *           return this.backend.getAll().pipe(
- *             map((response) => ({
- *               type: 'TODOS',
- *               todos: response.todos,
- *             }))
- *           );
- *         },
- *         onError: (action: GetTodos, error: any) => {
- *           // dispatch an undo action to undo the changes in the client state
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * This is correct, but because it set the concurrency to 1, it may not be performant.
- *
- * To fix that, you can provide the `id` function, like this:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   loadTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('GET_TODO'),
- *       fetch({
- *         id: (todo: GetTodo) => {
- *           return todo.id;
- *         },
- *         // provides an action
- *         run: (todo: GetTodo) => {
- *           return this.backend.getTodo(todo.id).map((response) => ({
- *             type: 'LOAD_TODO_SUCCESS',
- *             todo: response.todo,
- *           }));
- *         },
- *         onError: (action: GetTodo, error: any) => {
- *           // dispatch an undo action to undo the changes in the client state
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * With this setup, the requests for Todo 1 will run concurrently with the requests for Todo 2.
- *
- * In addition, if there are multiple requests for Todo 1 scheduled, it will only run the last one.
- *
- * @param opts
- */
-function fetch(opts) {
-    return (source) => {
-        if (opts.id) {
-            const groupedFetches = source.pipe(mapActionAndState(), (0, operators_1.groupBy)(([action, ...store]) => {
-                return opts.id(action, ...store);
-            }));
-            return groupedFetches.pipe((0, operators_1.mergeMap)((pairs) => pairs.pipe((0, operators_1.switchMap)(runWithErrorHandling(opts.run, opts.onError)))));
-        }
-        return source.pipe(mapActionAndState(), (0, operators_1.concatMap)(runWithErrorHandling(opts.run, opts.onError)));
-    };
-}
-exports.fetch = fetch;
-/**
- * @whatItDoes Handles data fetching as part of router navigation.
- *
- * Data fetching implemented naively suffers from race conditions and poor error handling.
- *
- * `navigation` addresses these problems.
- *
- * It checks if an activated router state contains the passed in component type, and, if it does, runs the `run`
- * callback. It provides the activated snapshot associated with the component and the current state. And it only runs
- * the last request.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   loadTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       // listens for the routerNavigation action from @ngrx/router-store
- *       navigation(TodoComponent, {
- *         run: (activatedRouteSnapshot: ActivatedRouteSnapshot) => {
- *           return this.backend
- *             .fetchTodo(activatedRouteSnapshot.params['id'])
- *             .pipe(
- *               map((todo) => ({
- *                 type: 'LOAD_TODO_SUCCESS',
- *                 todo: todo,
- *               }))
- *             );
- *         },
- *         onError: (
- *           activatedRouteSnapshot: ActivatedRouteSnapshot,
- *           error: any
- *         ) => {
- *           // we can log and error here and return null
- *           // we can also navigate back
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * @param component
- * @param opts
- */
-function navigation(component, opts) {
-    return (source) => {
-        const nav = source.pipe(mapActionAndState(), (0, operators_1.filter)(([action]) => isStateSnapshot(action)), (0, operators_1.map)(([action, ...slices]) => {
-            if (!isStateSnapshot(action)) {
-                // Because of the above filter we'll never get here,
-                // but this properly type narrows `action`
-                return;
-            }
-            return [
-                findSnapshot(component, action.payload.routerState.root),
-                ...slices,
-            ];
-        }), (0, operators_1.filter)(([snapshot]) => !!snapshot));
-        return nav.pipe((0, operators_1.switchMap)(runWithErrorHandling(opts.run, opts.onError)));
-    };
-}
-exports.navigation = navigation;
-function isStateSnapshot(action) {
-    return action.type === router_store_1.ROUTER_NAVIGATION;
-}
-function runWithErrorHandling(run, onError) {
-    return ([action, ...slices]) => {
-        try {
-            const r = wrapIntoObservable(run(action, ...slices));
-            return r.pipe((0, operators_1.catchError)((e) => wrapIntoObservable(onError(action, e))));
-        }
-        catch (e) {
-            return wrapIntoObservable(onError(action, e));
-        }
-    };
-}
-/**
- * @whatItDoes maps Observable<Action | [Action, State]> to
- * Observable<[Action, State]>
- */
-function mapActionAndState() {
-    return (source) => {
-        return source.pipe((0, operators_1.map)((value) => normalizeActionAndState(value)));
-    };
-}
-/**
- * @whatItDoes Normalizes either a bare action or an array of action and slices
- * into an array of action and slices (or undefined)
- */
-function normalizeActionAndState(args) {
-    let action, slices;
-    if (args instanceof Array) {
-        [action, ...slices] = args;
-    }
-    else {
-        slices = [];
-        action = args;
-    }
-    return [action, ...slices];
-}
-function findSnapshot(component, s) {
-    if (s.routeConfig && s.routeConfig.component === component) {
-        return s;
-    }
-    for (const c of s.children) {
-        const ss = findSnapshot(component, c);
-        if (ss) {
-            return ss;
-        }
-    }
-    return null;
-}
-function wrapIntoObservable(obj) {
-    if ((0, rxjs_1.isObservable)(obj)) {
-        return obj;
-    }
-    else if (!obj) {
-        return (0, rxjs_1.of)();
-    }
-    else {
-        return (0, rxjs_1.of)(obj);
-    }
-}

package/testing/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFirst = exports.readAll = void 0;
-var testing_utils_1 = require("./src/testing-utils");
-Object.defineProperty(exports, "readAll", { enumerable: true, get: function () { return testing_utils_1.readAll; } });
-Object.defineProperty(exports, "readFirst", { enumerable: true, get: function () { return testing_utils_1.readFirst; } });

package/testing/src/testing-utils.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFirst = exports.readAll = void 0;
-const operators_1 = require("rxjs/operators");
-/**
- * @deprecated This will be removed in a later version of Nx. Since RxJS 7, use firstValueFrom(obs$.pipe(toArray())) or lastValueFrom(obs$.pipe(toArray())).
- *
- * @whatItDoes reads all the values from an observable and returns a promise
- * with an array of all values. This should be used in combination with async/await.
- *
- * ## Example
- *
- * ```typescript
- * const obs = of(1, 2, 3, 4);
- * const res = await readAll(obs)
- * expect(res).toEqual([1, 2, 3, 4]);
- * ```
- */
-function readAll(o) {
-    return o.pipe((0, operators_1.toArray)()).toPromise();
-}
-exports.readAll = readAll;
-/**
- * @deprecated This will be removed in a later version of Nx. Since RxJS 7, use firstValueFrom(obs$)
- *
- * @whatItDoes reads the first value from an observable and returns a promise
- * with it. This should be used in combination with async/await.
- *
- * ## Example
- *
- * ```typescript
- * const obs = of(1, 2, 3, 4);
- * const res = await readFirst(obs)
- * expect(res).toEqual(1);
- * ```
- */
-function readFirst(o) {
-    return o.pipe((0, operators_1.first)()).toPromise();
-}
-exports.readFirst = readFirst;