@smartsoft001/crud-shell-angular 1.2.90 → 2.69.0

package/src/lib/services/page/page.service.spec.ts

@@ -0,0 +1,143 @@
+// Create interface for our mock
+import { ɵNoopNgZone as NoopNgZone, NgZone } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import {
+  BrowserTestingModule,
+  platformBrowserTesting,
+} from '@angular/platform-browser/testing';
+
+interface MockAuthService {
+  expectPermissions: jest.Mock;
+}
+
+// Mock getModelOptions
+const mockGetModelOptions = jest.fn();
+jest.mock('@smartsoft001/models', () => ({
+  getModelOptions: mockGetModelOptions,
+}));
+
+// Mock entire @smartsoft001/angular module
+jest.mock('@smartsoft001/angular', () => ({
+  AuthService: jest.fn().mockImplementation(() => ({
+    expectPermissions: jest.fn(),
+  })),
+}));
+
+import { AuthService } from '@smartsoft001/angular';
+
+import { PageService } from './page.service';
+import { CrudFullConfig } from '../../crud.config';
+
+TestBed.initTestEnvironment(BrowserTestingModule, platformBrowserTesting());
+
+describe('crud-shell-angular: PageService', () => {
+  let service: PageService<any>;
+  let authService: MockAuthService;
+  let config: CrudFullConfig<any>;
+
+  beforeEach(() => {
+    config = {
+      type: 'TestType',
+      title: 'Test Title',
+      apiUrl: 'http://test-api.com',
+      entity: {} as any,
+      add: true,
+      edit: true,
+      remove: true,
+    };
+
+    TestBed.configureTestingModule({
+      providers: [
+        PageService,
+        { provide: AuthService, useValue: { expectPermissions: jest.fn() } },
+        { provide: CrudFullConfig, useValue: config },
+        { provide: NgZone, useClass: NoopNgZone },
+      ],
+    });
+
+    service = TestBed.inject(PageService);
+    authService = TestBed.inject(AuthService) as unknown as MockAuthService;
+
+    // Reset all mocks before each test
+    jest.clearAllMocks();
+    mockGetModelOptions.mockReturnValue({
+      create: { permissions: ['create'] },
+      update: { permissions: ['update'] },
+      remove: { permissions: ['delete'] },
+    });
+  });
+
+  it('should create service', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('checkPermissions', () => {
+    it('should disable add when user lacks create permissions', () => {
+      authService.expectPermissions.mockReturnValue(false);
+      service.checkPermissions();
+      expect(config.add).toBe(false);
+    });
+
+    it('should keep add enabled when user has create permissions', () => {
+      authService.expectPermissions.mockReturnValue(true);
+      service.checkPermissions();
+      expect(config.add).toBe(true);
+    });
+
+    it('should disable edit when user lacks update permissions', () => {
+      authService.expectPermissions.mockReturnValue(false);
+      service.checkPermissions();
+      expect(config.edit).toBe(false);
+    });
+
+    it('should keep edit enabled when user has update permissions', () => {
+      authService.expectPermissions.mockReturnValue(true);
+      service.checkPermissions();
+      expect(config.edit).toBe(true);
+    });
+
+    it('should disable remove when user lacks delete permissions', () => {
+      authService.expectPermissions.mockReturnValue(false);
+      service.checkPermissions();
+      expect(config.remove).toBe(false);
+    });
+
+    it('should keep remove enabled when user has delete permissions', () => {
+      authService.expectPermissions.mockReturnValue(true);
+      service.checkPermissions();
+      expect(config.remove).toBe(true);
+    });
+
+    it('should not modify add when model has no create permissions defined', () => {
+      mockGetModelOptions.mockReturnValue({
+        create: {},
+      });
+      service.checkPermissions();
+      expect(config.add).toBe(true);
+    });
+
+    it('should not modify edit when model has no update permissions defined', () => {
+      mockGetModelOptions.mockReturnValue({
+        update: {},
+      });
+      service.checkPermissions();
+      expect(config.edit).toBe(true);
+    });
+
+    it('should not modify remove when model has no remove permissions defined', () => {
+      mockGetModelOptions.mockReturnValue({
+        remove: {},
+      });
+      service.checkPermissions();
+      expect(config.remove).toBe(true);
+    });
+
+    it('should handle undefined model options gracefully', () => {
+      mockGetModelOptions.mockReturnValue({});
+      service.checkPermissions();
+      expect(config.add).toBe(true);
+      expect(config.edit).toBe(true);
+      expect(config.remove).toBe(true);
+    });
+  });
+});

package/src/lib/services/page/page.service.ts

@@ -0,0 +1,44 @@
+import { inject, Injectable } from '@angular/core';
+
+import { AuthService } from '@smartsoft001/angular';
+import { getModelOptions } from '@smartsoft001/models';
+
+import { CrudFullConfig } from '../../crud.config';
+
+@Injectable()
+export class PageService<T> {
+  private authService = inject(AuthService);
+  private config = inject(CrudFullConfig<T>);
+
+  checkPermissions(): void {
+    const val: CrudFullConfig<T> = this.config;
+    const modelOptions = getModelOptions(val.type);
+
+    if (
+      val.add &&
+      modelOptions.create &&
+      modelOptions.create.permissions &&
+      !this.authService.expectPermissions(modelOptions.create.permissions)
+    ) {
+      val.add = false;
+    }
+
+    if (
+      val.edit &&
+      modelOptions.update &&
+      modelOptions.update.permissions &&
+      !this.authService.expectPermissions(modelOptions.update.permissions)
+    ) {
+      val.edit = false;
+    }
+
+    if (
+      val.remove &&
+      modelOptions.remove &&
+      modelOptions.remove.permissions &&
+      !this.authService.expectPermissions(modelOptions.remove.permissions)
+    ) {
+      val.remove = false;
+    }
+  }
+}

package/src/lib/services/search/search.service.spec.ts

@@ -0,0 +1,134 @@
+import { CrudSearchService } from './search.service';
+import { ICrudFilter, ICrudFilterQueryItem } from '../../models';
+
+describe('crud-shell-angular: CrudSearchService', () => {
+  let service: CrudSearchService;
+  const testQuery: ICrudFilterQueryItem = {
+    key: 'test',
+    value: 'value',
+    type: '=',
+  };
+
+  beforeEach(() => {
+    service = new CrudSearchService();
+  });
+
+  it('should create service', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('filter', () => {
+    it('should return empty object when disabled', () => {
+      service.setEnabled(false);
+      service.setFilter({ query: [] });
+      expect(service.filter).toEqual({});
+    });
+
+    it('should return filter value when enabled', () => {
+      const testFilter: ICrudFilter = { query: [testQuery] };
+      service.setEnabled(true);
+      service.setFilter(testFilter);
+      expect(service.filter).toEqual(testFilter);
+    });
+  });
+
+  describe('enabled', () => {
+    it('should return false by default', () => {
+      expect(service.enabled).toBe(false);
+    });
+
+    it('should return current enabled state', () => {
+      service.setEnabled(true);
+      expect(service.enabled).toBe(true);
+    });
+  });
+
+  describe('enabled$', () => {
+    it('should emit current enabled state', (done) => {
+      service.enabled$.subscribe((value) => {
+        expect(value).toBe(false);
+        done();
+      });
+    });
+
+    it('should emit new enabled state when changed', (done) => {
+      service.setEnabled(true);
+      service.enabled$.subscribe((value) => {
+        expect(value).toBe(true);
+        done();
+      });
+    });
+  });
+
+  describe('filter$', () => {
+    it('should emit empty object when disabled', (done) => {
+      service.setEnabled(false);
+      service.setFilter({ query: [testQuery] });
+
+      service.filter$.subscribe((value) => {
+        expect(value).toEqual({});
+        done();
+      });
+    });
+
+    it('should emit current filter when enabled', (done) => {
+      const testFilter: ICrudFilter = { query: [testQuery] };
+      service.setEnabled(true);
+      service.setFilter(testFilter);
+
+      service.filter$.subscribe((value) => {
+        expect(value).toEqual(testFilter);
+        done();
+      });
+    });
+
+    it('should emit new filter when changed', (done) => {
+      const testFilter: ICrudFilter = { query: [testQuery] };
+      service.setEnabled(true);
+
+      service.filter$.subscribe((value) => {
+        expect(value).toEqual(testFilter);
+        done();
+      });
+
+      service.setFilter(testFilter);
+    });
+  });
+
+  describe('setFilter', () => {
+    it('should update filter value', () => {
+      const testFilter: ICrudFilter = { query: [testQuery] };
+      service.setEnabled(true);
+      service.setFilter(testFilter);
+      expect(service.filter).toEqual(testFilter);
+    });
+
+    it('should not affect enabled state', () => {
+      service.setEnabled(false);
+      service.setFilter({ query: [] });
+      expect(service.enabled).toBe(false);
+    });
+  });
+
+  describe('setEnabled', () => {
+    it('should update enabled state', () => {
+      service.setEnabled(true);
+      expect(service.enabled).toBe(true);
+    });
+
+    it('should not affect filter value', () => {
+      const testFilter: ICrudFilter = { query: [testQuery] };
+      service.setFilter(testFilter);
+      service.setEnabled(true);
+      expect(service.filter).toEqual(testFilter);
+    });
+
+    it('should make filter return empty object when disabled', () => {
+      const testFilter: ICrudFilter = { query: [testQuery] };
+      service.setFilter(testFilter);
+      service.setEnabled(true);
+      service.setEnabled(false);
+      expect(service.filter).toEqual({});
+    });
+  });
+});

package/src/lib/services/search/search.service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { ICrudFilter } from '../../models';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CrudSearchService {
+  private _filterSource = new BehaviorSubject<Partial<ICrudFilter>>(null);
+  private _enabledSource = new BehaviorSubject<boolean>(false);
+
+  get filter(): Partial<ICrudFilter> {
+    if (!this._enabledSource.value) return {};
+    return this._filterSource.value;
+  }
+
+  get enabled(): boolean {
+    return this._enabledSource.value;
+  }
+
+  enabled$ = this._enabledSource.asObservable();
+
+  filter$: Observable<Partial<ICrudFilter>> = combineLatest([
+    this._filterSource.asObservable(),
+    this.enabled$,
+  ]).pipe(
+    map(([filter, enabled]) => {
+      if (!enabled) return {};
+      return filter;
+    }),
+  );
+
+  setFilter(val: Partial<ICrudFilter>): void {
+    this._filterSource.next(val);
+  }
+
+  setEnabled(val: boolean): void {
+    this._enabledSource.next(val);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,31 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../../dist/out-tsc",
+    "target": "ES2022",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": [],
+    "lib": ["dom", "es2018"],
+    "useDefineForClassFields": false,
+    "allowSyntheticDefaultImports": true
+  },
+  "angularCompilerOptions": {
+    "annotateForClosureCompiler": true,
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true,
+    "enableResourceInlining": true,
+    "compilationMode": "partial",
+    "enableIvy": false
+  },
+  "exclude": [
+    "src/test-setup.ts",
+    "**/*.spec.ts",
+    "**/*.test.ts",
+    "jest.config.ts"
+  ],
+  "include": ["**/*.ts"]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false,
+    "target": "ES2022",
+    "useDefineForClassFields": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "files": ["src/test-setup.ts"],
+  "include": ["**/*.spec.ts", "**/*.test.ts", "**/*.d.ts"]
+}

package/tslint.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../../tslint.json",
+  "rules": {
+    "directive-selector": [true, "attribute", "smart", "camelCase"],
+    "component-selector": [true, "element", "smart", "kebab-case"]
+  },
+  "linterOptions": {
+    "exclude": ["!**/*"]
+  }
+}

package/esm2022/index.mjs

@@ -1,18 +0,0 @@
-export * from "./lib/+state/crud.selectors";
-export * from "./lib/components";
-export * from "./lib/crud.config";
-export * from "./lib/crud.module";
-export * from "./lib/crud-full.module";
-export * from "./lib/factories/list-pagination/list-pagination.factory";
-export * from "./lib/pipes";
-export * from "./lib/providers/model-possibilities/model-possibilities.provider";
-export * from "./lib/services/crud/crud.service";
-export * from "./lib/services/page/page.service";
-export * from "./lib/services/search/search.service";
-export * from './lib/+state/crud.actions';
-export * from './lib/+state/crud.effects';
-export * from './lib/+state/crud.facade';
-export * from './lib/+state/crud.reducer';
-export * from './lib/models';
-export * from './lib/pages';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NydWQvc2hlbGwvYW5ndWxhci9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseURBQXlELENBQUM7QUFDeEUsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrRUFBa0UsQ0FBQztBQUNqRixjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vbGliLytzdGF0ZS9jcnVkLnNlbGVjdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2NvbXBvbmVudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9jcnVkLmNvbmZpZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2NydWQubW9kdWxlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvY3J1ZC1mdWxsLm1vZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2ZhY3Rvcmllcy9saXN0LXBhZ2luYXRpb24vbGlzdC1wYWdpbmF0aW9uLmZhY3RvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9waXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL3Byb3ZpZGVycy9tb2RlbC1wb3NzaWJpbGl0aWVzL21vZGVsLXBvc3NpYmlsaXRpZXMucHJvdmlkZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9zZXJ2aWNlcy9jcnVkL2NydWQuc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL3NlcnZpY2VzL3BhZ2UvcGFnZS5zZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9saWIvc2VydmljZXMvc2VhcmNoL3NlYXJjaC5zZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tICcuL2xpYi8rc3RhdGUvY3J1ZC5hY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbGliLytzdGF0ZS9jcnVkLmVmZmVjdHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvK3N0YXRlL2NydWQuZmFjYWRlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliLytzdGF0ZS9jcnVkLnJlZHVjZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BhZ2VzJzsiXX0=