@punks/backend-entity-manager 0.0.368 → 0.0.370

package/dist/cjs/types/abstractions/index.d.ts

@@ -34,6 +34,6 @@ export { IAppSessionService } from "./session";
 export { EntityManagerSettings } from "./settings";
 export { IEntitySnapshotService } from "./snapshot";
 export { IEntitySearchResults, IEntityFacet, IEntityFacetValue, IEntityFacets, ISearchResultsPaging, } from "./searchResults";
-export { ITask } from "./tasks";
+export { ITask, TaskContext, TaskRunType } from "./tasks";
 export * from "./tracking";
 export { EntityVersionOperation, EntityVersionInput, IEntityVersioningResults, IEntityVersioningProvider, IEntityVersionsSearchInput, } from "./versioning";

package/dist/cjs/types/platforms/nest/__test__/tests/tasks/manual-task.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/types/platforms/nest/__test__/tests/tasks/tasks.d.ts

@@ -10,3 +10,8 @@ export declare class ParallelTask implements ITask {
     execute(context: TaskContext): Promise<void>;
     static getCounter(): number;
 }
+export declare class ManualTask implements ITask {
+    private static counter;
+    execute(context: TaskContext): Promise<void>;
+    static getCounter(): number;
+}

package/dist/cjs/types/platforms/nest/decorators/tasks.d.ts

@@ -4,7 +4,7 @@ export declare enum TaskConcurrency {
     Multiple = "multiple"
 }
 export type TaskSettings = {
-    cronExpression: string;
+    cronExpression?: string;
     concurrency: TaskConcurrency;
 };
 export type TaskProps = TaskSettings & {

package/dist/cjs/types/platforms/nest/extensions/tasks/index.d.ts

@@ -1 +1,2 @@
 export { TasksModule } from "./module";
+export { TasksService } from "./services/tasks-service";

package/dist/cjs/types/platforms/nest/extensions/tasks/initializer.d.ts

@@ -1,12 +1,14 @@
 import { INestApplicationContext } from "@nestjs/common";
 import { IAppInitializer } from "../../../../abstractions";
 import { CustomDiscoveryService } from "../../ioc/discovery";
-import { TaskScheduler } from "./task-scheduler";
+import { TaskScheduler } from "./providers/scheduler";
+import { TasksRegistry } from "./providers/registry";
 export declare class TasksInitializer implements IAppInitializer {
     private readonly discover;
     private readonly scheduler;
+    private readonly registry;
     private readonly logger;
-    constructor(discover: CustomDiscoveryService, scheduler: TaskScheduler);
+    constructor(discover: CustomDiscoveryService, scheduler: TaskScheduler, registry: TasksRegistry);
     initialize(app: INestApplicationContext): Promise<void>;
     private registerCronJobs;
     private discoverTasks;

package/dist/cjs/types/platforms/nest/extensions/tasks/module.d.ts

@@ -1,5 +1,5 @@
 import { OnModuleDestroy } from "@nestjs/common";
-import { TaskScheduler } from "./task-scheduler";
+import { TaskScheduler } from "./providers/scheduler";
 export declare class TasksModule implements OnModuleDestroy {
     private readonly scheduler;
     constructor(scheduler: TaskScheduler);

package/dist/cjs/types/platforms/nest/extensions/tasks/providers/index.d.ts

@@ -0,0 +1,4 @@
+import { TasksRegistry } from "./registry";
+import { TaskScheduler } from "./scheduler";
+import { TaskShell } from "./shell";
+export declare const TasksModuleProviders: (typeof TaskShell | typeof TaskScheduler | typeof TasksRegistry)[];

package/dist/cjs/types/platforms/nest/extensions/tasks/providers/registry/index.d.ts

@@ -0,0 +1,10 @@
+import { TaskProps } from "../../../../decorators/tasks";
+import { ITask } from "../../../../../../abstractions";
+export declare class TasksRegistry {
+    private readonly tasks;
+    registerTask(props: TaskProps, instance: ITask): void;
+    getTask(name: string): {
+        props: TaskProps;
+        instance: ITask;
+    };
+}

package/dist/cjs/types/platforms/nest/extensions/tasks/{task-scheduler → providers/scheduler}/index.d.ts

@@ -1,13 +1,13 @@
 import { SchedulerRegistry } from "@nestjs/schedule";
-import { TaskProps } from "../../../decorators/tasks";
-import { ITask } from "../../../../../abstractions";
-import { TaskShell } from "../task-shell";
+import { TaskProps } from "../../../../decorators/tasks";
+import { ITask } from "../../../../../../abstractions";
+import { TaskShell } from "../shell";
 export declare class TaskScheduler {
     private schedulerRegistry;
     private readonly jobShell;
     private readonly logger;
-    private jobs;
+    private readonly cronJobs;
     constructor(schedulerRegistry: SchedulerRegistry, jobShell: TaskShell);
-    registerTask(job: TaskProps, instance: ITask): Promise<void>;
+    scheduleTask(job: TaskProps, instance: ITask): Promise<void>;
     stopAllTasks(): void;
 }

package/dist/cjs/types/platforms/nest/extensions/tasks/{task-shell → providers/shell}/index.d.ts

@@ -1,12 +1,13 @@
-import { TaskProps } from "../../../decorators/tasks";
-import { ILockRepository, ITask } from "../../../../../abstractions";
-import { EntityManagerRegistry } from "../../../ioc";
+import { TaskProps } from "../../../../decorators/tasks";
+import { ILockRepository, ITask } from "../../../../../../abstractions";
+import { EntityManagerRegistry } from "../../../../ioc";
+import { TaskRunType } from "../../../../../../abstractions/tasks";
 export declare class TaskShell {
     private readonly registry;
     private readonly operations;
     private readonly logger;
     constructor(registry: EntityManagerRegistry, operations: ILockRepository);
-    executeTask(instance: ITask, settings: TaskProps): Promise<void>;
+    executeTask(instance: ITask, settings: TaskProps, runType: TaskRunType): Promise<void>;
     private executeTaskParallel;
     private executeTaskSequential;
     private getTaskLockKey;

package/dist/cjs/types/platforms/nest/extensions/tasks/services/index.d.ts

@@ -0,0 +1,2 @@
+import { TasksService } from "./tasks-service";
+export declare const TaskModuleServices: (typeof TasksService)[];

package/dist/cjs/types/platforms/nest/extensions/tasks/services/tasks-service/index.d.ts

@@ -0,0 +1,10 @@
+import { TasksRegistry } from "../../providers/registry";
+import { TaskShell } from "../../providers/shell";
+export declare class TasksService {
+    private readonly jobShell;
+    private readonly registry;
+    private readonly logger;
+    constructor(jobShell: TaskShell, registry: TasksRegistry);
+    triggerTask(name: string): Promise<void>;
+    invokeTask(name: string): Promise<void>;
+}

package/dist/esm/index.js

@@ -150,6 +150,12 @@ var EntitySerializationFormat;
     EntitySerializationFormat["Xlsx"] = "xlsx";
 })(EntitySerializationFormat || (EntitySerializationFormat = {}));
 
+var TaskRunType;
+(function (TaskRunType) {
+    TaskRunType["Scheduled"] = "Scheduled";
+    TaskRunType["OnDemand"] = "OnDemand";
+})(TaskRunType || (TaskRunType = {}));
+
 var EntityVersionOperation;
 (function (EntityVersionOperation) {
     EntityVersionOperation["Create"] = "create";
@@ -34779,12 +34785,6 @@ JobsModule = JobsModule_1 = __decorate([
         JobsProviderFactory])
 ], JobsModule);
 
-var TaskRunType;
-(function (TaskRunType) {
-    TaskRunType["Scheduled"] = "Scheduled";
-    TaskRunType["OnDemand"] = "OnDemand";
-})(TaskRunType || (TaskRunType = {}));
-
 const getCronCurrentSchedule = (cronExpression, ref) => {
     const interval = parser$1.parseExpression(cronExpression, {
         currentDate: ref,
@@ -34805,40 +34805,42 @@ let TaskShell = TaskShell_1 = class TaskShell {
         this.operations = operations;
         this.logger = Log.getLogger(TaskShell_1.name);
     }
-    async executeTask(instance, settings) {
+    async executeTask(instance, settings, runType) {
         switch (settings.concurrency) {
             case TaskConcurrency.Single:
-                return await this.executeTaskSequential(instance, settings);
+                return await this.executeTaskSequential(instance, settings, runType);
             case TaskConcurrency.Multiple:
-                return await this.executeTaskParallel(instance, settings);
+                return await this.executeTaskParallel(instance, settings, runType);
             default:
                 throw new Error(`Unknown task concurrency: ${settings.concurrency}`);
         }
     }
-    async executeTaskParallel(instance, settings) {
-        await this.invokeTask(instance, settings);
+    async executeTaskParallel(instance, settings, runType) {
+        await this.invokeTask(instance, settings, runType);
     }
-    async executeTaskSequential(instance, settings) {
-        const currentSchedule = getCronCurrentSchedule(settings.cronExpression, new Date());
+    async executeTaskSequential(instance, settings, runType) {
+        const currentSchedule = settings.cronExpression && runType === TaskRunType.Scheduled
+            ? getCronCurrentSchedule(settings.cronExpression, new Date())
+            : undefined;
         const lockKey = this.getTaskLockKey(settings, currentSchedule);
         const lock = await this.operations.acquireLock({
             lockUid: lockKey,
         });
         if (lock.available) {
-            await this.invokeTask(instance, settings);
+            await this.invokeTask(instance, settings, runType);
         }
     }
     getTaskLockKey(settings, cronSchedule) {
-        return `task:${settings.name}:${floorDateToSecond(cronSchedule).toISOString()}`;
+        return `task:${settings.name}:${cronSchedule ? floorDateToSecond(cronSchedule).toISOString() : newUuid$1()}`;
     }
-    async invokeTask(instance, settings) {
+    async invokeTask(instance, settings, runType) {
         try {
             this.logger.info(`Task ${settings.name} -> starting`);
             await instance.execute({
                 name: settings.name,
                 startedAt: new Date(),
                 runId: newUuid$1(),
-                runType: TaskRunType.Scheduled,
+                runType,
             });
             this.logger.info(`Task ${settings.name} -> completed`);
         }
@@ -34865,19 +34867,22 @@ let TaskScheduler = TaskScheduler_1 = class TaskScheduler {
         this.schedulerRegistry = schedulerRegistry;
         this.jobShell = jobShell;
         this.logger = new Logger(TaskScheduler_1.name);
-        this.jobs = [];
+        this.cronJobs = [];
     }
-    async registerTask(job, instance) {
+    async scheduleTask(job, instance) {
+        if (!job.cronExpression) {
+            throw new Error(`Task ${job.name} has no cron expression`);
+        }
         const cronJob = new dist.CronJob(job.cronExpression, async (context) => {
-            await this.jobShell.executeTask(instance, job);
+            await this.jobShell.executeTask(instance, job, TaskRunType.Scheduled);
         });
         this.schedulerRegistry.addCronJob(job.name, cronJob);
         cronJob.start();
-        this.jobs.push(cronJob);
+        this.cronJobs.push(cronJob);
         this.logger.log(`Jobs ${job.name} registered`);
     }
     stopAllTasks() {
-        this.jobs.forEach((job) => {
+        this.cronJobs.forEach((job) => {
             job.stop();
         });
     }
@@ -34888,11 +34893,37 @@ TaskScheduler = TaskScheduler_1 = __decorate([
         TaskShell])
 ], TaskScheduler);
 
+let TasksRegistry = class TasksRegistry {
+    constructor() {
+        this.tasks = new Map();
+    }
+    registerTask(props, instance) {
+        if (this.tasks.has(props.name)) {
+            throw new Error(`Task with name ${props.name} already registered`);
+        }
+        this.tasks.set(props.name, {
+            instance,
+            props,
+        });
+    }
+    getTask(name) {
+        const task = this.tasks.get(name);
+        if (!task) {
+            throw new Error(`Task with name ${name} not found`);
+        }
+        return task;
+    }
+};
+TasksRegistry = __decorate([
+    Injectable()
+], TasksRegistry);
+
 var TasksInitializer_1;
 let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
-    constructor(discover, scheduler) {
+    constructor(discover, scheduler, registry) {
         this.discover = discover;
         this.scheduler = scheduler;
+        this.registry = registry;
         this.logger = new Logger(TasksInitializer_1.name);
     }
     async initialize(app) {
@@ -34908,7 +34939,10 @@ let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
                 .join(", ")}`);
         }
         for (const task of tasks) {
-            await this.scheduler.registerTask(task.meta, task.discoveredClass.instance);
+            this.registry.registerTask(task.meta, task.discoveredClass.instance);
+            if (task.meta.cronExpression) {
+                await this.scheduler.scheduleTask(task.meta, task.discoveredClass.instance);
+            }
         }
     }
     async discoverTasks() {
@@ -34918,9 +34952,47 @@ let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
 TasksInitializer = TasksInitializer_1 = __decorate([
     WpAppInitializer(),
     __metadata("design:paramtypes", [CustomDiscoveryService,
-        TaskScheduler])
+        TaskScheduler,
+        TasksRegistry])
 ], TasksInitializer);
 
+const TasksModuleProviders = [TaskScheduler, TaskShell, TasksRegistry];
+
+var TasksService_1;
+let TasksService = TasksService_1 = class TasksService {
+    constructor(jobShell, registry) {
+        this.jobShell = jobShell;
+        this.registry = registry;
+        this.logger = new Logger(TasksService_1.name);
+    }
+    async triggerTask(name) {
+        this.logger.log(`Manual task ${name} -> trigger`);
+        const task = this.registry.getTask(name);
+        this.jobShell
+            .executeTask(task.instance, task.props, TaskRunType.OnDemand)
+            .then(() => {
+            this.logger.log(`Manual task ${name} -> completed`);
+        })
+            .catch((e) => {
+            this.logger.error(`Manual task ${name} -> error: ${e.message}`);
+        });
+        this.logger.log(`Manual task ${name} -> triggered`);
+    }
+    async invokeTask(name) {
+        this.logger.log(`Manual task ${name} -> invoke`);
+        const task = this.registry.getTask(name);
+        await this.jobShell.executeTask(task.instance, task.props, TaskRunType.OnDemand);
+        this.logger.log(`Manual task ${name} -> completed`);
+    }
+};
+TasksService = TasksService_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [TaskShell,
+        TasksRegistry])
+], TasksService);
+
+const TaskModuleServices = [TasksService];
+
 let TasksModule = class TasksModule {
     constructor(scheduler) {
         this.scheduler = scheduler;
@@ -34932,7 +35004,8 @@ let TasksModule = class TasksModule {
 TasksModule = __decorate([
     Module({
         imports: [EntityManagerModule],
-        providers: [TasksInitializer, TaskScheduler, TaskShell],
+        providers: [TasksInitializer, ...TasksModuleProviders, ...TaskModuleServices],
+        exports: [...TaskModuleServices],
     }),
     __metadata("design:paramtypes", [TaskScheduler])
 ], TasksModule);
@@ -44618,5 +44691,5 @@ class TestingAppSessionService {
     }
 }
 
-export { AUTHENTICATION_EVENTS_NAMESPACE, ApiKeyAccess, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSession, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsBucketModule, AwsDynamoDbModule, AwsEmailModule, AwsJobsModule, AwsS3BucketError, AwsS3BucketProvider, AwsS3MediaError, AwsS3MediaModule, AwsS3MediaProvider, AwsSecretsModule, AwsSecretsProvider, AwsSesEmailTemplate, BucketItemType, CacheService, ConnectorMode, CurrentUser, CustomDiscoveryModule, CustomDiscoveryService, DynamoDbCacheInstance, DynamoDbCollection, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityParseResult, EntityParseValidationError, EntitySeeder, EntitySerializationFormat, EntitySerializer, EntitySnapshotService, EntityVersionOperation, EventsService, ExclusiveOperationResult, FilesManager, IEntityVersionsCursor, InMemoryBucketProvider, InMemoryEmailProvider, InMemoryFileProvider, InMemoryMediaProvider, InMemorySecretsProvider, InvalidCredentialsError, JobConcurrency, JobInstance, JobProviderState, JobRunType, JobSchedule, JobStatus, JobsModule, JobsService, LockNotFoundError, MediaLibraryService, MemberOf, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestEntitySerializer, NestEntitySnapshotService, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, OperationLockService, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, Permissions, PipelineController, PipelineErrorType, PipelineInvocationError, PipelineStatus, PipelineStepErrorType, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, QueryBuilderOperation, ReplicationMode, Roles, SanityMediaError, SanityMediaModule, SanityMediaProvider, SecretsService, SendgridEmailModule, SendgridEmailTemplate, SortDirection, TaskConcurrency, TasksModule, TestingAppSessionService, TrackingService, TypeOrmQueryBuilder, TypeOrmRepository, TypeormCacheInstance, TypeormOperationLockRepository, UserCreationError, UserRegistrationError, WpApiKeysService, WpAppInitializer, WpAwsSesEmailTemplate, WpBucketProvider, WpCacheInstance, WpEmailLogger, WpEmailProvider, WpEmailTemplate, WpEmailTemplateMiddleware, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConnectorMapper, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEntitySerializer, WpEntitySnapshotService, WpEntityVersioningProvider, WpEventsTracker, WpFileProvider, WpFileReferenceRepository, WpGlobalAuthenticationMiddleware, WpMediaFolderRepository, WpMediaProvider, WpMediaReferenceRepository, WpPermissionsService, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpTask, WpUserRolesService, WpUserService, awsBatchSettings, buildPermissionsGuard, buildProviderToken, buildRolesGuard, createContainer, createExpressFileResponse, fieldRequiredValidator, getEntityManagerProviderToken, getLocalizedText, newUuid, renderHandlebarsTemplate, sessionStorage, toEntitiesImportInput };
+export { AUTHENTICATION_EVENTS_NAMESPACE, ApiKeyAccess, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSession, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsBucketModule, AwsDynamoDbModule, AwsEmailModule, AwsJobsModule, AwsS3BucketError, AwsS3BucketProvider, AwsS3MediaError, AwsS3MediaModule, AwsS3MediaProvider, AwsSecretsModule, AwsSecretsProvider, AwsSesEmailTemplate, BucketItemType, CacheService, ConnectorMode, CurrentUser, CustomDiscoveryModule, CustomDiscoveryService, DynamoDbCacheInstance, DynamoDbCollection, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityParseResult, EntityParseValidationError, EntitySeeder, EntitySerializationFormat, EntitySerializer, EntitySnapshotService, EntityVersionOperation, EventsService, ExclusiveOperationResult, FilesManager, IEntityVersionsCursor, InMemoryBucketProvider, InMemoryEmailProvider, InMemoryFileProvider, InMemoryMediaProvider, InMemorySecretsProvider, InvalidCredentialsError, JobConcurrency, JobInstance, JobProviderState, JobRunType, JobSchedule, JobStatus, JobsModule, JobsService, LockNotFoundError, MediaLibraryService, MemberOf, MissingEntityIdError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestEntitySerializer, NestEntitySnapshotService, NestPipelineTemplate, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, OperationLockService, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, Permissions, PipelineController, PipelineErrorType, PipelineInvocationError, PipelineStatus, PipelineStepErrorType, PipelinesBuilder, PipelinesRunner, PlatformEvents, Public, QueryBuilderBase, QueryBuilderOperation, ReplicationMode, Roles, SanityMediaError, SanityMediaModule, SanityMediaProvider, SecretsService, SendgridEmailModule, SendgridEmailTemplate, SortDirection, TaskConcurrency, TaskRunType, TasksModule, TasksService, TestingAppSessionService, TrackingService, TypeOrmQueryBuilder, TypeOrmRepository, TypeormCacheInstance, TypeormOperationLockRepository, UserCreationError, UserRegistrationError, WpApiKeysService, WpAppInitializer, WpAwsSesEmailTemplate, WpBucketProvider, WpCacheInstance, WpEmailLogger, WpEmailProvider, WpEmailTemplate, WpEmailTemplateMiddleware, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConnectorMapper, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEntitySerializer, WpEntitySnapshotService, WpEntityVersioningProvider, WpEventsTracker, WpFileProvider, WpFileReferenceRepository, WpGlobalAuthenticationMiddleware, WpMediaFolderRepository, WpMediaProvider, WpMediaReferenceRepository, WpPermissionsService, WpPipeline, WpRolesService, WpSendgridEmailTemplate, WpTask, WpUserRolesService, WpUserService, awsBatchSettings, buildPermissionsGuard, buildProviderToken, buildRolesGuard, createContainer, createExpressFileResponse, fieldRequiredValidator, getEntityManagerProviderToken, getLocalizedText, newUuid, renderHandlebarsTemplate, sessionStorage, toEntitiesImportInput };
 //# sourceMappingURL=index.js.map