@flusys/nestjs-task-manager 7.1.0 → 8.0.0-beta.1

package/cjs/interfaces/task-manager-module.interface.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/cjs/interfaces/task.interface.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/cjs/modules/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./task-manager.module"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/modules/task-manager.module.js

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "TaskManagerModule", {
-    enumerable: true,
-    get: function() {
-        return TaskManagerModule;
-    }
-});
-const _modules = require("@flusys/nestjs-shared/modules");
-const _common = require("@nestjs/common");
-const _jwt = require("@nestjs/jwt");
-const _taskmanagerconstants = require("../config/task-manager.constants");
-const _controllers = require("../controllers");
-const _taskboardgateway = require("../gateways/task-board.gateway");
-const _services = require("../services");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-const CONTROLLERS = [
-    _controllers.TaskBoardController,
-    _controllers.TaskListController,
-    _controllers.TaskController,
-    _controllers.TaskLabelController,
-    _controllers.TaskCommentController
-];
-const EXPORTED_SERVICES = [
-    _services.TaskManagerConfigService,
-    _services.TaskManagerDataSourceProvider,
-    _services.TaskBoardService,
-    _services.TaskListService,
-    _services.TaskService,
-    _services.TaskLabelService,
-    _services.TaskCommentService,
-    _services.TaskActivityService
-];
-let TaskManagerModule = class TaskManagerModule {
-    static forRoot(options) {
-        return {
-            module: TaskManagerModule,
-            global: options.global ?? false,
-            imports: [
-                _modules.CacheModule,
-                _modules.UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.buildProviders(options),
-                _jwt.JwtService,
-                _taskboardgateway.TaskBoardGateway
-            ],
-            exports: [
-                ...EXPORTED_SERVICES,
-                _taskboardgateway.TaskBoardGateway
-            ]
-        };
-    }
-    static forRootAsync(options) {
-        return {
-            module: TaskManagerModule,
-            global: options.global ?? false,
-            imports: [
-                ...options.imports || [],
-                _modules.CacheModule,
-                _modules.UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.createAsyncProviders(options),
-                ...this.buildProviders(),
-                _jwt.JwtService,
-                _taskboardgateway.TaskBoardGateway
-            ],
-            exports: [
-                ...EXPORTED_SERVICES,
-                _taskboardgateway.TaskBoardGateway
-            ]
-        };
-    }
-    static buildProviders(options) {
-        const providers = [
-            ...EXPORTED_SERVICES
-        ];
-        if (options) {
-            providers.unshift({
-                provide: _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS,
-                useValue: options
-            });
-        }
-        providers.push((0, _modules.createModuleEventsProvider)('task-manager', _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS));
-        return providers;
-    }
-    static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS,
-                    useFactory: async (...args)=>({
-                            ...options,
-                            config: await options.useFactory(...args)
-                        }),
-                    inject: options.inject || []
-                }
-            ];
-        }
-        const factoryClass = options.useClass || options.useExisting;
-        if (!factoryClass) return [];
-        const providers = [
-            {
-                provide: _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS,
-                useFactory: async (factory)=>({
-                        ...options,
-                        config: await factory.createTaskManagerOptions()
-                    }),
-                inject: [
-                    factoryClass
-                ]
-            }
-        ];
-        if (options.useClass) {
-            providers.push({
-                provide: options.useClass,
-                useClass: options.useClass
-            });
-        }
-        return providers;
-    }
-};
-TaskManagerModule = _ts_decorate([
-    (0, _common.Module)({})
-], TaskManagerModule);

package/cjs/modules/task-manager.module.spec.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _taskmanagermodule = require("./task-manager.module");
-const _taskmanagerconstants = require("../config/task-manager.constants");
-const _controllers = require("../controllers");
-const _taskboardgateway = require("../gateways/task-board.gateway");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function providerTokens(providers) {
-    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
-}
-describe('TaskManagerModule', ()=>{
-    describe('forRoot', ()=>{
-        it('should default to a non-global module with all controllers registered', ()=>{
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRoot({});
-            expect(dynamicModule.module).toBe(_taskmanagermodule.TaskManagerModule);
-            expect(dynamicModule.global).toBe(false);
-            expect(dynamicModule.controllers).toEqual([
-                _controllers.TaskBoardController,
-                _controllers.TaskListController,
-                _controllers.TaskController,
-                _controllers.TaskLabelController,
-                _controllers.TaskCommentController
-            ]);
-        });
-        it('should respect global: true', ()=>{
-            expect(_taskmanagermodule.TaskManagerModule.forRoot({
-                global: true
-            }).global).toBe(true);
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            expect(_taskmanagermodule.TaskManagerModule.forRoot({
-                includeController: false
-            }).controllers).toEqual([]);
-        });
-        it('should register TaskBoardGateway as both a provider and an export', ()=>{
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRoot({});
-            expect(providerTokens(dynamicModule.providers)).toContain(_taskboardgateway.TaskBoardGateway);
-            expect(dynamicModule.exports).toContain(_taskboardgateway.TaskBoardGateway);
-        });
-        it('should register a TASK_MANAGER_MODULE_OPTIONS provider carrying the given options', ()=>{
-            const options = {
-                bootstrapAppConfig: {}
-            };
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRoot(options);
-            const provider = dynamicModule.providers.find((p)=>p.provide === _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS);
-            expect(provider.useValue).toBe(options);
-        });
-    });
-    describe('forRootAsync', ()=>{
-        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
-            let FakeImportedModule = class FakeImportedModule {
-            };
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRootAsync({
-                imports: [
-                    FakeImportedModule
-                ]
-            });
-            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
-                FakeImportedModule
-            ]));
-        });
-        it('should still register TaskBoardGateway when using async registration', ()=>{
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRootAsync({
-                useFactory: jest.fn()
-            });
-            expect(providerTokens(dynamicModule.providers)).toContain(_taskboardgateway.TaskBoardGateway);
-            expect(dynamicModule.exports).toContain(_taskboardgateway.TaskBoardGateway);
-        });
-        it('useFactory: builds a TASK_MANAGER_MODULE_OPTIONS provider merging resolved config', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                foo: 'bar'
-            });
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRootAsync({
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const provider = dynamicModule.providers.find((p)=>p.provide === _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS);
-            expect(provider.inject).toEqual([
-                'SOME_TOKEN'
-            ]);
-            const resolved = await provider.useFactory('injected');
-            expect(useFactory).toHaveBeenCalledWith('injected');
-            expect(resolved.config).toEqual({
-                foo: 'bar'
-            });
-        });
-        it('useClass: registers both the class provider and an options provider calling createTaskManagerOptions()', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createTaskManagerOptions", jest.fn().mockResolvedValue({
-                        foo: 'from-class'
-                    }));
-                }
-            };
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRootAsync({
-                useClass: MyOptionsFactory
-            });
-            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
-            expect(classProvider.useClass).toBe(MyOptionsFactory);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS);
-            const instance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(instance);
-            expect(instance.createTaskManagerOptions).toHaveBeenCalled();
-            expect(resolved.config).toEqual({
-                foo: 'from-class'
-            });
-        });
-        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createTaskManagerOptions", jest.fn());
-                }
-            };
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRootAsync({
-                useExisting: MyOptionsFactory
-            });
-            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-        });
-        it('should register no TASK_MANAGER_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
-            const dynamicModule = _taskmanagermodule.TaskManagerModule.forRootAsync({});
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS);
-        });
-    });
-});

package/cjs/services/index.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./task-manager-config.service"), exports);
-_export_star(require("./task-manager-datasource.provider"), exports);
-_export_star(require("./task-board.service"), exports);
-_export_star(require("./task-list.service"), exports);
-_export_star(require("./task-activity.service"), exports);
-_export_star(require("./task-label.service"), exports);
-_export_star(require("./task-comment.service"), exports);
-_export_star(require("./task.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/services/task-activity.service.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "TaskActivityService", {
-    enumerable: true,
-    get: function() {
-        return TaskActivityService;
-    }
-});
-const _common = require("@nestjs/common");
-const _entities = require("../entities");
-const _taskmanagerdatasourceprovider = require("./task-manager-datasource.provider");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let TaskActivityService = class TaskActivityService {
-    async log(taskId, boardId, userId, action, oldValue, newValue) {
-        const repo = await this.ensureRepository();
-        const activity = repo.create({
-            taskId,
-            boardId,
-            userId,
-            action,
-            oldValue,
-            newValue
-        });
-        await repo.save(activity);
-    }
-    async ensureRepository() {
-        if (!this.repository) {
-            this.repository = await this.dataSourceProvider.getRepository(_entities.TaskActivity);
-        }
-        return this.repository;
-    }
-    constructor(dataSourceProvider){
-        _define_property(this, "dataSourceProvider", void 0);
-        _define_property(this, "repository", void 0);
-        this.dataSourceProvider = dataSourceProvider;
-        this.repository = null;
-    }
-};
-TaskActivityService = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    }),
-    _ts_param(0, (0, _common.Inject)(_taskmanagerdatasourceprovider.TaskManagerDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider === "undefined" ? Object : _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider
-    ])
-], TaskActivityService);

package/cjs/services/task-activity.service.spec.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _testing = require("@nestjs/testing");
-const _entities = require("../entities");
-const _taskactivityservice = require("./task-activity.service");
-const _taskmanagerdatasourceprovider = require("./task-manager-datasource.provider");
-describe('TaskActivityService', ()=>{
-    let service;
-    let mockRepo;
-    let mockDataSourceProvider;
-    beforeEach(async ()=>{
-        mockRepo = {
-            create: jest.fn((data)=>({
-                    id: 'activity-uuid-1',
-                    ...data
-                })),
-            save: jest.fn().mockResolvedValue(undefined)
-        };
-        mockDataSourceProvider = {
-            getRepository: jest.fn().mockResolvedValue(mockRepo)
-        };
-        const module = await _testing.Test.createTestingModule({
-            providers: [
-                _taskactivityservice.TaskActivityService,
-                {
-                    provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(_taskactivityservice.TaskActivityService);
-    });
-    it('lazily resolves the TaskActivity repository from the DataSource provider', async ()=>{
-        await service.log('task-1', 'board-1', 'user-1', 'task.created', null, {
-            title: 'New task'
-        });
-        expect(mockDataSourceProvider.getRepository).toHaveBeenCalledWith(_entities.TaskActivity);
-        expect(mockDataSourceProvider.getRepository).toHaveBeenCalledTimes(1);
-    });
-    it('caches the repository across multiple log calls (only resolved once)', async ()=>{
-        await service.log('task-1', 'board-1', 'user-1', 'task.created', null, {
-            title: 'New task'
-        });
-        await service.log('task-1', 'board-1', 'user-1', 'task.moved', {
-            listId: 'a'
-        }, {
-            listId: 'b'
-        });
-        expect(mockDataSourceProvider.getRepository).toHaveBeenCalledTimes(1);
-        expect(mockRepo.save).toHaveBeenCalledTimes(2);
-    });
-    it('records "task.created" activity with title in newValue and null oldValue', async ()=>{
-        await service.log('task-1', 'board-1', 'user-1', 'task.created', null, {
-            title: 'New task'
-        });
-        expect(mockRepo.create).toHaveBeenCalledWith({
-            taskId: 'task-1',
-            boardId: 'board-1',
-            userId: 'user-1',
-            action: 'task.created',
-            oldValue: null,
-            newValue: {
-                title: 'New task'
-            }
-        });
-        expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-            action: 'task.created',
-            newValue: {
-                title: 'New task'
-            }
-        }));
-    });
-    it('records "task.moved" activity with old and new listId', async ()=>{
-        await service.log('task-1', 'board-1', 'user-1', 'task.moved', {
-            listId: 'list-old'
-        }, {
-            listId: 'list-new'
-        });
-        expect(mockRepo.create).toHaveBeenCalledWith(expect.objectContaining({
-            action: 'task.moved',
-            oldValue: {
-                listId: 'list-old'
-            },
-            newValue: {
-                listId: 'list-new'
-            }
-        }));
-    });
-    it('records "task.assigned" activity with old and new assigneeIds', async ()=>{
-        await service.log('task-1', 'board-1', 'user-1', 'task.assigned', {
-            assigneeIds: [
-                'u1'
-            ]
-        }, {
-            assigneeIds: [
-                'u1',
-                'u2'
-            ]
-        });
-        expect(mockRepo.create).toHaveBeenCalledWith(expect.objectContaining({
-            action: 'task.assigned',
-            oldValue: {
-                assigneeIds: [
-                    'u1'
-                ]
-            },
-            newValue: {
-                assigneeIds: [
-                    'u1',
-                    'u2'
-                ]
-            }
-        }));
-    });
-    it('records an activity with a null userId (system-initiated action)', async ()=>{
-        await service.log('task-1', 'board-1', null, 'task.created', null, {
-            title: 'System task'
-        });
-        expect(mockRepo.create).toHaveBeenCalledWith(expect.objectContaining({
-            userId: null
-        }));
-    });
-});