@punks/backend-entity-manager 0.0.366 → 0.0.368

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

@@ -34,5 +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 * from "./tracking";
 export { EntityVersionOperation, EntityVersionInput, IEntityVersioningResults, IEntityVersioningProvider, IEntityVersionsSearchInput, } from "./versioning";

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

@@ -0,0 +1,13 @@
+export declare enum TaskRunType {
+    Scheduled = "Scheduled",
+    OnDemand = "OnDemand"
+}
+export type TaskContext = {
+    name: string;
+    runId: string;
+    runType: TaskRunType;
+    startedAt: Date;
+};
+export interface ITask {
+    execute(context: TaskContext): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { ITask } from "../../../../../abstractions";
+import { TaskContext } from "../../../../../abstractions/tasks";
+export declare class SingleTask implements ITask {
+    private static counter;
+    execute(context: TaskContext): Promise<void>;
+    static getCounter(): number;
+}
+export declare class ParallelTask implements ITask {
+    private static counter;
+    execute(context: TaskContext): Promise<void>;
+    static getCounter(): number;
+}

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

@@ -20,5 +20,6 @@ export { WpEntitySeeder, EntitySeederProps } from "./seed";
 export { WpEntitySerializer, EntitySerializerProps } from "./serializer";
 export { WpEntitySnapshotService, EntitySnapshotServiceProps } from "./snapshot";
 export { EntityManagerSymbols } from "./symbols";
+export { WpTask, TaskSettings, TaskConcurrency } from "./tasks";
 export { WpEventsTracker, EventsTrackerProps } from "./tracking";
 export { WpEntityVersioningProvider, EntityVersioningProviderProps, } from "./versioning";

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

@@ -0,0 +1,13 @@
+export declare const TASK_KEY = "wp_task";
+export declare enum TaskConcurrency {
+    Single = "single",
+    Multiple = "multiple"
+}
+export type TaskSettings = {
+    cronExpression: string;
+    concurrency: TaskConcurrency;
+};
+export type TaskProps = TaskSettings & {
+    name: string;
+};
+export declare function WpTask(name: string, settings: TaskSettings): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

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

@@ -1,3 +1,4 @@
 export * from "./authentication";
 export * from "./multi-tenancy";
 export * from "./jobs";
+export * from "./tasks";

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

@@ -0,0 +1 @@
+export { TasksModule } from "./module";

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { TaskProps } from "../../../decorators/tasks";
+import { ILockRepository, ITask } from "../../../../../abstractions";
+import { EntityManagerRegistry } from "../../../ioc";
+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>;
+    private executeTaskParallel;
+    private executeTaskSequential;
+    private getTaskLockKey;
+    private invokeTask;
+    private get operationsLockService();
+}

package/dist/cjs/types/utils/cron.d.ts

@@ -0,0 +1 @@
+export declare const getCronCurrentSchedule: (cronExpression: string, ref: Date) => Date;

package/dist/cjs/types/utils/dates.d.ts

@@ -0,0 +1 @@
+export declare function floorDateToSecond(date: Date): Date;

package/dist/esm/index.js

@@ -4247,6 +4247,19 @@ const WpEntitySnapshotService = (entityName, props = {}) => applyDecorators(Inje
     ...props,
 }));
 
+const TASK_KEY = "wp_task";
+var TaskConcurrency;
+(function (TaskConcurrency) {
+    TaskConcurrency["Single"] = "single";
+    TaskConcurrency["Multiple"] = "multiple";
+})(TaskConcurrency || (TaskConcurrency = {}));
+function WpTask(name, settings) {
+    return applyDecorators(Injectable(), SetMetadata(TASK_KEY, {
+        name,
+        ...settings,
+    }));
+}
+
 const WpEventsTracker = (props = {}) => applyDecorators(Injectable(), SetMetadata(EntityManagerSymbols.EventsTracker, {
     ...props,
 }));
@@ -34766,6 +34779,164 @@ 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,
+    });
+    return interval.prev().toDate();
+};
+
+function floorDateToSecond(date) {
+    const flooredDate = new Date(date);
+    flooredDate.setMilliseconds(0);
+    return flooredDate;
+}
+
+var TaskShell_1;
+let TaskShell = TaskShell_1 = class TaskShell {
+    constructor(registry, operations) {
+        this.registry = registry;
+        this.operations = operations;
+        this.logger = Log.getLogger(TaskShell_1.name);
+    }
+    async executeTask(instance, settings) {
+        switch (settings.concurrency) {
+            case TaskConcurrency.Single:
+                return await this.executeTaskSequential(instance, settings);
+            case TaskConcurrency.Multiple:
+                return await this.executeTaskParallel(instance, settings);
+            default:
+                throw new Error(`Unknown task concurrency: ${settings.concurrency}`);
+        }
+    }
+    async executeTaskParallel(instance, settings) {
+        await this.invokeTask(instance, settings);
+    }
+    async executeTaskSequential(instance, settings) {
+        const currentSchedule = getCronCurrentSchedule(settings.cronExpression, new Date());
+        const lockKey = this.getTaskLockKey(settings, currentSchedule);
+        const lock = await this.operations.acquireLock({
+            lockUid: lockKey,
+        });
+        if (lock.available) {
+            await this.invokeTask(instance, settings);
+        }
+    }
+    getTaskLockKey(settings, cronSchedule) {
+        return `task:${settings.name}:${floorDateToSecond(cronSchedule).toISOString()}`;
+    }
+    async invokeTask(instance, settings) {
+        try {
+            this.logger.info(`Task ${settings.name} -> starting`);
+            await instance.execute({
+                name: settings.name,
+                startedAt: new Date(),
+                runId: newUuid$1(),
+                runType: TaskRunType.Scheduled,
+            });
+            this.logger.info(`Task ${settings.name} -> completed`);
+        }
+        catch (error) {
+            this.logger.exception(`Task ${settings.name} -> failed`, error);
+        }
+    }
+    get operationsLockService() {
+        return this.registry
+            .getContainer()
+            .getEntitiesServicesLocator()
+            .resolveOperationLockService();
+    }
+};
+TaskShell = TaskShell_1 = __decorate([
+    Injectable(),
+    __param(1, Inject(getEntityManagerProviderToken("OperationsLockRepository"))),
+    __metadata("design:paramtypes", [EntityManagerRegistry, Object])
+], TaskShell);
+
+var TaskScheduler_1;
+let TaskScheduler = TaskScheduler_1 = class TaskScheduler {
+    constructor(schedulerRegistry, jobShell) {
+        this.schedulerRegistry = schedulerRegistry;
+        this.jobShell = jobShell;
+        this.logger = new Logger(TaskScheduler_1.name);
+        this.jobs = [];
+    }
+    async registerTask(job, instance) {
+        const cronJob = new dist.CronJob(job.cronExpression, async (context) => {
+            await this.jobShell.executeTask(instance, job);
+        });
+        this.schedulerRegistry.addCronJob(job.name, cronJob);
+        cronJob.start();
+        this.jobs.push(cronJob);
+        this.logger.log(`Jobs ${job.name} registered`);
+    }
+    stopAllTasks() {
+        this.jobs.forEach((job) => {
+            job.stop();
+        });
+    }
+};
+TaskScheduler = TaskScheduler_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [SchedulerRegistry,
+        TaskShell])
+], TaskScheduler);
+
+var TasksInitializer_1;
+let TasksInitializer = TasksInitializer_1 = class TasksInitializer {
+    constructor(discover, scheduler) {
+        this.discover = discover;
+        this.scheduler = scheduler;
+        this.logger = new Logger(TasksInitializer_1.name);
+    }
+    async initialize(app) {
+        await this.registerCronJobs();
+        this.logger.log("Tasks initialized 🎰");
+    }
+    async registerCronJobs() {
+        const tasks = await this.discoverTasks();
+        const duplicatedJobs = tasks.filter((job, index, self) => index !== self.findIndex((t) => t.meta.name === job.meta.name));
+        if (duplicatedJobs.length) {
+            throw new Error(`Duplicated jobs found: ${duplicatedJobs
+                .map((j) => j.meta.name)
+                .join(", ")}`);
+        }
+        for (const task of tasks) {
+            await this.scheduler.registerTask(task.meta, task.discoveredClass.instance);
+        }
+    }
+    async discoverTasks() {
+        return await this.discover.providersWithMetaAtKey(TASK_KEY);
+    }
+};
+TasksInitializer = TasksInitializer_1 = __decorate([
+    WpAppInitializer(),
+    __metadata("design:paramtypes", [CustomDiscoveryService,
+        TaskScheduler])
+], TasksInitializer);
+
+let TasksModule = class TasksModule {
+    constructor(scheduler) {
+        this.scheduler = scheduler;
+    }
+    onModuleDestroy() {
+        this.scheduler.stopAllTasks();
+    }
+};
+TasksModule = __decorate([
+    Module({
+        imports: [EntityManagerModule],
+        providers: [TasksInitializer, TaskScheduler, TaskShell],
+    }),
+    __metadata("design:paramtypes", [TaskScheduler])
+], TasksModule);
+
 const createExpressFileResponse = (res, file) => {
     res.set({
         "Content-Type": file.contentType,
@@ -44447,5 +44618,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, 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, 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, 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 };
 //# sourceMappingURL=index.js.map