@verisoft/store 20.0.0 → 20.1.0

package/.eslintrc.json

@@ -0,0 +1,43 @@
+{
+  "extends": ["../../../.eslintrc.base.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts"],
+      "extends": [
+        "plugin:@nx/angular",
+        "plugin:@angular-eslint/template/process-inline-templates"
+      ],
+      "rules": {
+        "@angular-eslint/directive-selector": [
+          "error",
+          {
+            "type": "attribute",
+            "prefix": "lib",
+            "style": "camelCase"
+          }
+        ],
+        "@angular-eslint/component-selector": [
+          "error",
+          {
+            "type": "element",
+            "prefix": "lib",
+            "style": "kebab-case"
+          }
+        ]
+      }
+    },
+    {
+      "files": ["*.html"],
+      "extends": ["plugin:@nx/angular-template"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": "error"
+      }
+    }
+  ]
+}

package/jest.config.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+export default {
+  displayName: 'store',
+  preset: '../../../jest.preset.js',
+  setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+  coverageDirectory: '../../../coverage/src/libs/store',
+  transform: {
+    '^.+\\.(ts|mjs|js|html)$': [
+      'jest-preset-angular',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+        stringifyContentPathRegex: '\\.(html|svg)$',
+      },
+    ],
+  },
+  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'],
+  snapshotSerializers: [
+    'jest-preset-angular/build/serializers/no-ng-attributes',
+    'jest-preset-angular/build/serializers/ng-snapshot',
+    'jest-preset-angular/build/serializers/html-comment',
+  ],
+};

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../../dist/src/libs/store",
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

@@ -1,29 +1,15 @@
 {
   "name": "@verisoft/store",
-  "version": "20.0.0",
+  "version": "20.1.0",
   "peerDependencies": {
     "@angular/router": "~20.2.0",
     "@ngrx/effects": "~20.0.0",
     "@ngrx/store": "~20.0.0",
-    "@verisoft/core": "~20.0.0",
+    "@verisoft/core": "~20.1.0",
     "rxjs": "~7.8.0"
   },
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
-  },
-  "module": "fesm2022/verisoft-store.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/verisoft-store.mjs"
-    }
-  },
-  "dependencies": {
-    "tslib": "^2.3.0"
   }
-}
+}

package/project.json

@@ -0,0 +1,36 @@
+{
+  "name": "store",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "src/libs/store/src",
+  "prefix": "lib",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/angular:package",
+      "outputs": ["{workspaceRoot}/dist/{projectRoot}"],
+      "options": {
+        "project": "src/libs/store/ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "src/libs/store/tsconfig.lib.prod.json"
+        },
+        "development": {
+          "tsConfig": "src/libs/store/tsconfig.lib.json"
+        }
+      },
+      "defaultConfiguration": "production"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "src/libs/store/jest.config.ts"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from './lib/detail-state/detail.actions';
+export * from './lib/detail-state/detail.reducer';
+export * from './lib/detail-state/detail.effects';
+export * from './lib/detail-state/detail.models';
+
+export * from './lib/table-state/actions';
+export * from './lib/table-state/reducers';
+export * from './lib/table-state/effects';
+export * from './lib/table-state/models';
+
+export * from './lib/binding-state/binding.actions';
+export * from './lib/binding-state/binding.effects';

package/src/lib/binding-state/binding.actions.ts

@@ -0,0 +1,76 @@
+import { createAction, props } from '@ngrx/store';
+
+export function createAddBindingAction<TCreate>(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Add bindings`,
+    props<{ binding: TCreate }>()
+  );
+}
+
+export function createAddBindingsAction<TCreate>(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Add bindings`,
+    props<{ bindings: TCreate[] }>()
+  );
+}
+
+export function createAddBindingsFailureAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Add bindings failure`,
+    props<{ error: any }>()
+  );
+}
+
+export function createAddBindingsSuccessAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Add bindings success`
+  );
+}
+
+export function createEditBindingAction<TEdit>(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Edit binding`,
+    props<{ binding: TEdit }>()
+  );
+}
+
+export function createEditBindingFailureAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Edit binding failure`,
+    props<{ error: any }>()
+  );
+}
+
+export function createEditBindingSuccessAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Edit binding success`
+  );
+}
+
+export function createDeleteBindingAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Delete binding`,
+    props<{ id: number | string }>()
+  );
+}
+
+export function createDeleteBindingsAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Delete bindings`,
+    props<{ bindingIds: number[] }>()
+  );
+}
+
+export function createDeleteBindingsFailureAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Delete bindings failure`,
+    props<{ error: any }>()
+  );
+}
+
+export function createDeleteBindingsSuccessAction(bindingsRepository: string) {
+  return createAction(
+    `[${bindingsRepository}/API] Delete bindings success`
+  );
+}
+

package/src/lib/binding-state/binding.effects.ts

@@ -0,0 +1,472 @@
+import { Actions, createEffect, ofType } from '@ngrx/effects';
+import {
+  catchError,
+  map,
+  Observable,
+  of,
+  switchMap,
+  tap,
+  withLatestFrom,
+} from 'rxjs';
+import {
+  createAddBindingAction,
+  createAddBindingsAction,
+  createAddBindingsFailureAction,
+  createAddBindingsSuccessAction,
+  createDeleteBindingAction,
+  createDeleteBindingsAction,
+  createDeleteBindingsFailureAction,
+  createDeleteBindingsSuccessAction,
+  createEditBindingAction,
+  createEditBindingFailureAction,
+  createEditBindingSuccessAction,
+} from './binding.actions';
+
+export function createSingleBindingEffectsWithEdit<
+  T extends { id: number | string },
+  TCreate,
+  TEdit extends { id?: number | string }
+>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingSingularName: string,
+  bindingPluralName: string,
+  addFunction: (
+    bindings: TCreate,
+  ) => Observable<any>,
+  editFunction: (binding: TEdit, detailId: number | string) => Observable<any>,
+  deleteFunction: (
+    bindingIds: string | number,
+    detailId: number | string
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any,
+  tableService: any,
+  overrideDetailWithBinding = false,
+) {
+  const addEffect = createAddBindingEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingPluralName,
+    addFunction,
+    snackbar,
+    translateService,
+  );
+
+  const editEffect = createEditBindingEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingSingularName,
+    editFunction,
+    snackbar,
+    translateService,
+    overrideDetailWithBinding
+  );
+
+  const deleteEffect = createDeleteBindingEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingPluralName,
+    deleteFunction,
+    snackbar,
+    translateService
+  );
+
+  const modifiedSuccessEffect = createBindingModifiedSuccessEffect(
+    bindingsRepository,
+    actions$,
+    tableService
+  );
+
+  return { addEffect, editEffect, deleteEffect, modifiedSuccessEffect };
+}
+
+export function createBindingsEffectsWithEdit<
+  T extends { id: number | string },
+  TCreate,
+  TEdit extends { id?: number | string }
+>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingSingularName: string,
+  bindingPluralName: string,
+  addFunction: (
+    bindings: TCreate[],
+    detailId: number | string
+  ) => Observable<any>,
+  editFunction: (binding: TEdit, detailId: number | string) => Observable<any>,
+  deleteFunction: (
+    bindingIds: number[],
+    detailId: number | string
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any,
+  tableService: any,
+  overrideDetailWithBinding = false,
+) {
+  const addEffect = createAddBindingsEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingPluralName,
+    addFunction,
+    snackbar,
+    translateService
+  );
+
+  const editEffect = createEditBindingEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingSingularName,
+    editFunction,
+    snackbar,
+    translateService,
+    overrideDetailWithBinding
+  );
+
+  const deleteEffect = createDeleteBindingsEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingPluralName,
+    deleteFunction,
+    snackbar,
+    translateService
+  );
+
+  const modifiedSuccessEffect = createBindingModifiedSuccessEffect(
+    bindingsRepository,
+    actions$,
+    tableService
+  );
+
+  return { addEffect, editEffect, deleteEffect, modifiedSuccessEffect };
+}
+
+export function createBindingsEffects<
+  T extends { id: number | string },
+  TCreate
+>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingPluralName: string,
+  addFunction: (
+    bindings: TCreate[],
+    detailId: number | string
+  ) => Observable<any>,
+  deleteFunction: (
+    bindingIds: number[],
+    detailId: number | string
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any,
+  tableService: any
+) {
+  const addEffect = createAddBindingsEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingPluralName,
+    addFunction,
+    snackbar,
+    translateService
+  );
+
+  const deleteEffect = createDeleteBindingsEffect(
+    bindingsRepository,
+    actions$,
+    detail$,
+    bindingPluralName,
+    deleteFunction,
+    snackbar,
+    translateService
+  );
+
+  const modifiedSuccessEffect = createBindingModifiedSuccessEffect(
+    bindingsRepository,
+    actions$,
+    tableService
+  );
+
+  return { addEffect, deleteEffect, modifiedSuccessEffect };
+}
+
+function createAddBindingEffect<T extends { id: number | string }, TCreate>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingPluralName: string,
+  addFunction: (
+    bindings: TCreate,
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any,
+) {
+  return createEffect(() =>
+    actions$.pipe(
+      ofType(createAddBindingAction<TCreate>(bindingsRepository)),
+      withLatestFrom(detail$),
+      switchMap(([{ binding }, detail]) => {
+        const translatedPluralName =
+          translateService.instant(bindingPluralName);
+        const successMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.SUCCESS_ADD'
+        )} ${translatedPluralName}!`;
+        const failureMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.FAILURE_ADD'
+        )} ${translatedPluralName}!`;
+
+        return addFunction(binding).pipe(
+          map(() => {
+            snackbar.showSuccess(successMessage);
+            return createAddBindingsSuccessAction(bindingsRepository)();
+          }),
+          catchError((error) => {
+            snackbar.showError(failureMessage);
+            return of(
+              createAddBindingsFailureAction(bindingsRepository)({ error })
+            );
+          })
+        );
+      })
+    )
+  );
+}
+
+function createAddBindingsEffect<T extends { id: number | string }, TCreate>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingPluralName: string,
+  addFunction: (
+    bindings: TCreate[],
+    detailId: number | string
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any
+) {
+  return createEffect(() =>
+    actions$.pipe(
+      ofType(createAddBindingsAction<TCreate>(bindingsRepository)),
+      withLatestFrom(detail$),
+      switchMap(([{ bindings }, detail]) => {
+        const translatedPluralName =
+          translateService.instant(bindingPluralName);
+        const successMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.SUCCESS_ADD'
+        )} ${translatedPluralName}!`;
+        const failureMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.FAILURE_ADD'
+        )} ${translatedPluralName}!`;
+
+        if (!detail?.id) {
+          snackbar.showError(failureMessage);
+          return of(
+            createAddBindingsFailureAction(bindingsRepository)({
+              error: failureMessage,
+            })
+          );
+        }
+
+        return addFunction(bindings, detail.id).pipe(
+          map(() => {
+            snackbar.showSuccess(successMessage);
+            return createAddBindingsSuccessAction(bindingsRepository)();
+          }),
+          catchError((error) => {
+            snackbar.showError(failureMessage);
+            return of(
+              createAddBindingsFailureAction(bindingsRepository)({ error })
+            );
+          })
+        );
+      })
+    )
+  );
+}
+
+function createEditBindingEffect<
+  T extends { id: number | string },
+  TEdit extends { id?: number | string }
+>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingSingularName: string,
+  editFunction: (binding: TEdit, detailId: number | string) => Observable<any>,
+  snackbar: any,
+  translateService: any,
+  overrideDetailWithBinding = false,
+) {
+  return createEffect(() =>
+    actions$.pipe(
+      ofType(createEditBindingAction<TEdit>(bindingsRepository)),
+      withLatestFrom(detail$),
+      switchMap(([{ binding }, detail]) => {
+        const translatedPluralName =
+          translateService.instant(bindingSingularName);
+        const successMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.SUCCESS_EDIT'
+        )} ${translatedPluralName}!`;
+        const failureMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.FAILURE_EDIT'
+        )} ${translatedPluralName}!`;
+
+        const id = overrideDetailWithBinding ? binding?.id : detail?.id;
+        if (!id) {
+          snackbar.showError(failureMessage);
+          return of(
+            createEditBindingFailureAction(bindingsRepository)({
+              error: failureMessage,
+            })
+          );
+        }
+
+        return editFunction(binding, id).pipe(
+          map(() => {
+            snackbar.showSuccess(successMessage);
+            return createEditBindingSuccessAction(bindingsRepository)();
+          }),
+          catchError((error) => {
+            snackbar.showError(failureMessage);
+            return of(
+              createEditBindingFailureAction(bindingsRepository)({ error })
+            );
+          })
+        );
+      })
+    )
+  );
+}
+
+function createDeleteBindingEffect<T extends { id: number | string }>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingPluralName: string,
+  deleteFunction: (
+    bindingIds: string | number,
+    detailId: string | number
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any
+) {
+  return createEffect(() =>
+    actions$.pipe(
+      ofType(createDeleteBindingAction(bindingsRepository)),
+      withLatestFrom(detail$),
+      switchMap(([{ id }, detail]) => {
+        const translatedPluralName =
+          translateService.instant(bindingPluralName);
+        const successMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.SUCCESS_DELETE'
+        )} ${translatedPluralName}!`;
+        const failureMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.FAILURE_DELETE'
+        )} ${translatedPluralName}!`;
+
+        if (!id && !detail?.id) {
+          snackbar.showError(failureMessage);
+          return of(
+            createDeleteBindingsFailureAction(bindingsRepository)({
+              error: failureMessage,
+            })
+          );
+        }
+
+        return deleteFunction(id, id ?? detail?.id).pipe(
+          map(() => {
+            snackbar.showSuccess(successMessage);
+            return createDeleteBindingsSuccessAction(bindingsRepository)();
+          }),
+          catchError((error) => {
+            snackbar.showError(failureMessage);
+            return of(
+              createDeleteBindingsFailureAction(bindingsRepository)({ error })
+            );
+          })
+        );
+      })
+    )
+  );
+}
+
+function createDeleteBindingsEffect<T extends { id: number | string }>(
+  bindingsRepository: string,
+  actions$: Actions,
+  detail$: Observable<T | undefined>,
+  bindingPluralName: string,
+  deleteFunction: (
+    bindingIds: number[],
+    detailId: string | number
+  ) => Observable<any>,
+  snackbar: any,
+  translateService: any
+) {
+  return createEffect(() =>
+    actions$.pipe(
+      ofType(createDeleteBindingsAction(bindingsRepository)),
+      withLatestFrom(detail$),
+      switchMap(([{ bindingIds }, detail]) => {
+        const translatedPluralName =
+          translateService.instant(bindingPluralName);
+        const successMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.SUCCESS_DELETE'
+        )} ${translatedPluralName}!`;
+        const failureMessage = `${translateService.instant(
+          'BINDINGS_EFFECTS.FAILURE_DELETE'
+        )} ${translatedPluralName}!`;
+
+        if (!detail?.id) {
+          snackbar.showError(failureMessage);
+          return of(
+            createDeleteBindingsFailureAction(bindingsRepository)({
+              error: failureMessage,
+            })
+          );
+        }
+
+        return deleteFunction(bindingIds, detail.id).pipe(
+          map(() => {
+            snackbar.showSuccess(successMessage);
+            return createDeleteBindingsSuccessAction(bindingsRepository)();
+          }),
+          catchError((error) => {
+            snackbar.showError(failureMessage);
+            return of(
+              createDeleteBindingsFailureAction(bindingsRepository)({ error })
+            );
+          })
+        );
+      })
+    )
+  );
+}
+
+function createBindingModifiedSuccessEffect(
+  bindingsRepository: string,
+  actions$: Actions,
+  tableService: any
+) {
+  return createEffect(
+    () =>
+      actions$.pipe(
+        ofType(
+          createAddBindingsSuccessAction(bindingsRepository),
+          createEditBindingSuccessAction(bindingsRepository),
+          createDeleteBindingsSuccessAction(bindingsRepository)
+        ),
+        tap(() => {
+          tableService.forceReload();
+        })
+      ),
+    { dispatch: false }
+  );
+}