@elyx-code/editor-ui 0.0.2

package/src/services/editor/publication/publication.ts

@@ -0,0 +1,578 @@
+import {
+	CloudProviders,
+	IDeploymentStepDefinition,
+	IInfrastructureResource,
+	InfrastructureResourceDetails,
+	InfrastructureResourceType,
+	ProjectPublicationEventName,
+	PublicationStatus,
+	PublishingSequenceStep,
+	InfrastructureResource as InfrastructureResourceDef,
+	ILiveMessageDTO,
+	LiveMessageEventType,
+	IPublication,
+	PublicationStepStatus
+} from '@elyx-code/definitions';
+import {
+	BaseEntityNames,
+	checkHasBaseEntity,
+	CloudHostedCodebaseInfrastructureResource,
+	CompiledLocalCodebaseInfrastructureResource,
+	DefinitionEntityState,
+	ExplicitInfrastructureResource,
+	ExtensionContextType,
+	ExtensionsRegistry,
+	HttpApiInfrastructureResource,
+	ImplicitGlobalInfrastructureResource,
+	IPublicationRun,
+	IPublicationRunContext,
+	ProjectState,
+	RelationalDatabaseInfrastructureResource
+} from '@elyx-code/project-logic-tree';
+import { EditorService } from '../EditorService';
+import dayjs from 'dayjs';
+import { Events, Logger } from '@elyx-code/common-ts-utils';
+
+export function getRelationalDBInstanceNameFromEntityId(
+	entityId: string,
+	envIdentifier: string
+): string {
+	return `entity-${entityId}-database-${envIdentifier}`;
+}
+
+export function getEndpointResourceIdFromEntityId(
+	entityId: string,
+	envIdentifier: string
+): string {
+	return `entity-${entityId}-endpoint-${envIdentifier}`;
+}
+
+export function getCronResourceIdFromEntityId(
+	entityId: string,
+	envIdentifier: string
+): string {
+	return `entity-${entityId}-cron-${envIdentifier}`;
+}
+
+export function getFunctionResourceIdFromEntityId(
+	entityId: string,
+	envIdentifier: string
+): string {
+	return `entity-${entityId}-function-${envIdentifier}`;
+}
+
+export class PublicationStep implements IDeploymentStepDefinition<
+	ExplicitInfrastructureResource | ImplicitGlobalInfrastructureResource
+> {
+	stepType: PublishingSequenceStep;
+	id: string;
+	resourceType: InfrastructureResourceType;
+	index: number;
+	dependency: string[] = [];
+	lastEvent: ProjectPublicationEventName;
+	lastEventTimestamp: string | null = null;
+
+	status: PublicationStepStatus = PublicationStepStatus.Queued;
+
+	publicationRun: PublicationRun;
+
+	startedAt: string | null = null;
+	updatedAt: string | null = null;
+	createdAt: string | null = null;
+
+	// Resolved infrastructure resource details
+	// Only available after the step is run
+	resource:
+		| ExplicitInfrastructureResource
+		| ImplicitGlobalInfrastructureResource;
+
+	constructor(
+		stepType: PublishingSequenceStep,
+		id: string,
+		resourceType: InfrastructureResourceType,
+		initialStatus: PublicationStepStatus,
+		dependency: string[],
+		index: number,
+		lastEventTimestamp: string,
+		publicationRun: PublicationRun,
+		resource:
+			| ExplicitInfrastructureResource
+			| ImplicitGlobalInfrastructureResource
+	) {
+		this.stepType = stepType;
+		this.id = id;
+		this.resourceType = resourceType;
+		this.status = initialStatus;
+		this.dependency = dependency;
+		this.index = index;
+		this.lastEventTimestamp = lastEventTimestamp;
+		this.publicationRun = publicationRun;
+		this.resource = resource;
+	}
+
+	toJSON(): IDeploymentStepDefinition {
+		return {
+			stepType: this.stepType,
+			id: this.id,
+			resourceType: this.resourceType,
+			index: this.index,
+			status: this.status,
+			dependency: this.dependency,
+			lastEvent: this.lastEvent,
+			startedAt: this.startedAt,
+			updatedAt: this.updatedAt,
+			createdAt: this.createdAt,
+			resource: {
+				resourceId: this.resource?.resourceId,
+				resourceType: this.resource?.resourceType,
+				provider: this.resource?.provider,
+				details: this.resource?.details,
+				status: this.resource?.status,
+				name: this.resource?.name
+			} as InfrastructureResourceDef
+		};
+	}
+
+	async update(step: IDeploymentStepDefinition) {
+		this.status = step.status;
+		this.dependency = step.dependency;
+		this.index = step.index;
+		this.stepType = step.stepType;
+		this.resourceType = step.resourceType;
+		this.lastEvent = step.lastEvent;
+		this.id = step.id;
+		this.resource?.setDetails(step.resource?.details);
+		this.startedAt = step.startedAt || null;
+		this.updatedAt = step.updatedAt || null;
+		this.createdAt = step.createdAt || null;
+	}
+
+	// async error(
+	// 	event: ProjectPublicationEventName,
+	// 	_extraPayload: { [key: string]: any } = {}
+	// ) {
+	// 	this.status = PublicationStepStatus.Failed;
+	// 	this.lastEvent = event;
+	// }
+
+	// async complete(
+	// 	event: ProjectPublicationEventName,
+	// 	_extraPayload: { [key: string]: any } = {}
+	// ) {
+	// 	this.status = PublicationStepStatus.Success;
+	// 	this.lastEvent = event;
+	// }
+
+	// // Execute the step's business logic and set the status, resourceId and final details
+	// async run() {
+	// 	switch (this.stepType) {
+	// 		case PublishingSequenceStep.CodeCompilation: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.RelationalDatabaseDeployment: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.ExecutePublicationCompletedEvent: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.RelationalDatabaseDeletion: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.HttpApiDeployment: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.HttpApiDeletion: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.InfrastructureValuesCodebaseInterpolation: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.BusinessLogicCodebaseDeployment: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.CodebaseCleanup: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.MigrateRelationalDatabase: {
+	// 			break;
+	// 		}
+	// 		case PublishingSequenceStep.BundleCodebase: {
+	// 			break;
+	// 		}
+	// 		default: {
+	// 			throw new Error(`Step type ${this.stepType} is not implemented yet`);
+	// 		}
+	// 	}
+	// }
+}
+
+export enum InfrastructureResourceStatus {
+	Ready = 'ready',
+	Provisioning = 'provisioning',
+	Queued = 'queued',
+	ProvisioningFailed = 'provisioning-failed',
+	Deleting = 'deleting',
+	DeletingFailed = 'deleting-failed',
+	Deleted = 'deleted'
+}
+
+export class InfrastructureResource implements IInfrastructureResource {
+	provisionedBy!: PublicationStep;
+	publicationRun: PublicationRun;
+
+	resourceType: InfrastructureResourceType;
+	provider: CloudProviders;
+	resourceId!: string;
+	// Only available after the step is run
+	details: InfrastructureResourceDetails | null = null;
+	name: string | null = null;
+
+	status: InfrastructureResourceStatus = InfrastructureResourceStatus.Queued;
+
+	constructor(
+		publicationRun: PublicationRun,
+		resourceType: InfrastructureResourceType,
+		provider: CloudProviders
+	) {
+		this.publicationRun = publicationRun;
+		this.resourceType = resourceType;
+		this.provider = provider;
+	}
+
+	setDetails(details: InfrastructureResourceDetails) {
+		this.details = details;
+	}
+
+	setStatus(status: InfrastructureResourceStatus) {
+		this.status = status;
+	}
+
+	setProvisionedBy(step: PublicationStep) {
+		this.provisionedBy = step;
+	}
+}
+
+export class PublicationRun implements IPublicationRun, IPublicationRunContext {
+	id: string;
+	projectAutoIncrementPublicationCount: number;
+	projectPublishedSemanticVersion: string;
+	projectVersion: string;
+	projectBranchId: string;
+	private _envIdentifier: string;
+	projectId: string;
+	triggeredBy: string;
+	createdAt: string;
+	updatedAt: string;
+	status: PublicationStatus;
+
+	steps: PublicationStep[] = [];
+
+	editor: EditorService;
+
+	explicitResources: Map<string, ExplicitInfrastructureResource> = new Map();
+
+	implicitGlobalResources: Map<
+		| InfrastructureResourceType.CompiledLocalCodebase
+		| InfrastructureResourceType.CloudHostedCodebase,
+		ImplicitGlobalInfrastructureResource | null
+	> = new Map();
+
+	finalGlobalEvent: ProjectPublicationEventName | null = null;
+	finalStatus: PublicationStatus.Success | PublicationStatus.Failed | null =
+		null;
+
+	contextType: ExtensionContextType.PublicationRun =
+		ExtensionContextType.PublicationRun;
+	extensionsRegistry!: ExtensionsRegistry<any, any, any, PublicationRun>;
+
+	constructor(data: IPublication, editor: EditorService) {
+		this.id = data.id;
+		this.projectAutoIncrementPublicationCount =
+			data.projectAutoIncrementPublicationCount;
+		this.projectPublishedSemanticVersion =
+			data.projectPublishedSemanticVersion;
+		this.projectVersion = data.projectVersion;
+		this.projectBranchId = data.projectBranchId;
+		this._envIdentifier = data.envIdentifier;
+		this.projectId = data.projectId;
+		this.triggeredBy = data.triggeredBy;
+		this.createdAt = data.createdAt;
+		this.updatedAt = data.updatedAt;
+		this.status = data.status;
+		this.editor = editor;
+
+		this.initRegistry();
+	}
+
+	get off(): Events['off'] {
+		return this.extensionsRegistry.off;
+	}
+	get on(): Events['on'] {
+		return this.extensionsRegistry.on;
+	}
+	get emit(): Events['emit'] {
+		return this.extensionsRegistry.emit;
+	}
+	get emitAsync(): Events['emitAsync'] {
+		return this.extensionsRegistry.emitAsync;
+	}
+	get emitAsyncAll(): Events['emitAsyncAll'] {
+		return this.extensionsRegistry.emitAsyncAll;
+	}
+	get emitAsyncAllSettled(): Events['emitAsyncAllSettled'] {
+		return this.extensionsRegistry.emitAsyncAllSettled;
+	}
+	get emitAsyncSequentially(): Events['emitAsyncSequentially'] {
+		return this.extensionsRegistry.emitAsyncSequentially;
+	}
+	get emitAsyncSequentiallyAll(): Events['emitAsyncSequentiallyAll'] {
+		return this.extensionsRegistry.emitAsyncSequentiallyAll;
+	}
+	get emitAsyncSequentiallyAllSettled(): Events['emitAsyncSequentiallyAllSettled'] {
+		return this.extensionsRegistry.emitAsyncSequentiallyAllSettled;
+	}
+
+	get project(): ProjectState {
+		return this.editor.project;
+	}
+
+	get envIdentifier(): string {
+		return (
+			this.envIdentifier || this.editor.branchHead?.identifier || 'main'
+		);
+	}
+
+	getInfraTypes(
+		resourceTypes: InfrastructureResourceType[]
+	): PublicationStep[] {
+		return this.steps.filter((step) =>
+			resourceTypes.includes(step.resourceType)
+		);
+	}
+
+	getStepsTypes(stepTypes: PublishingSequenceStep[]): PublicationStep[] {
+		return this.steps.filter((step) => stepTypes.includes(step.stepType));
+	}
+
+	toIds(steps: PublicationStep[]): string[] {
+		return steps.map((step) => step.id);
+	}
+
+	getResourceForEntity(
+		entity: DefinitionEntityState
+	):
+		| ExplicitInfrastructureResource
+		| ImplicitGlobalInfrastructureResource
+		| null {
+		const resource = Array.from(this.explicitResources.values()).find(
+			(resource) => resource.owners.has(entity.id)
+		);
+
+		if (resource) {
+			return resource;
+		}
+
+		return null;
+	}
+
+	async init() {
+		await this.initResources();
+	}
+
+	// Every reasource that will be used in the publication process
+	// Should be initialized here
+	// We use the project state to determine which resources are needed
+	async initResources() {
+		this.implicitGlobalResources.set(
+			InfrastructureResourceType.CompiledLocalCodebase,
+			new CompiledLocalCodebaseInfrastructureResource(
+				this,
+				CloudProviders.Amazon
+			)
+		);
+		this.implicitGlobalResources.set(
+			InfrastructureResourceType.CloudHostedCodebase,
+			new CloudHostedCodebaseInfrastructureResource(
+				this,
+				CloudProviders.Amazon
+			)
+		);
+
+		const endpointEntities = this.project.entities.filter((entity) =>
+			checkHasBaseEntity(entity, BaseEntityNames.HTTP_ENDPOINT)
+		);
+
+		const dbEntities = this.project.entities.filter((entity) =>
+			checkHasBaseEntity(entity, BaseEntityNames.RELATIONAL_DATABASE)
+		);
+
+		if (!!dbEntities.length) {
+			dbEntities.forEach((entity) => {
+				const resource = new RelationalDatabaseInfrastructureResource(
+					this,
+					[entity],
+					CloudProviders.Amazon
+				);
+
+				this.explicitResources.set(resource.resourceId, resource);
+			});
+		}
+
+		if (!!endpointEntities.length) {
+			const resource = new HttpApiInfrastructureResource(
+				this,
+				endpointEntities,
+				CloudProviders.Amazon
+			);
+
+			this.explicitResources.set(resource.resourceId, resource);
+		}
+	}
+
+	// Generate the steps needed for the publication process
+	setSteps(steps: IDeploymentStepDefinition[], emittedAt: string): void {
+		steps.forEach((step) => {
+			this.addStep(step, emittedAt);
+		});
+
+		this.editor.emit(
+			ProjectPublicationEventName.ProjectPublishRequestAcknowledged,
+			{}
+		);
+	}
+
+	// Initializes a new step instance
+	addStep(step: IDeploymentStepDefinition, emittedAt: string): void {
+		const dependencies = step.dependency || [];
+
+		// If all dependencies are not present, throw an error
+		if (dependencies.length) {
+			const missingDependencies = dependencies.filter(
+				(dep) => !this.steps.find((s) => s.id === dep)
+			);
+
+			if (missingDependencies.length) {
+				throw new Error(
+					`Missing dependencies: ${missingDependencies.join(', ')}`
+				);
+			}
+		}
+
+		// if (!step.resource) {
+		// 	throw new Error(
+		// 		`Resource not found for step ${step.stepType} (${step.id})`
+		// 	);
+		// }
+
+		const existingStep = this.steps.find((s) => s.id === step.id);
+
+		if (!existingStep) {
+			// const resource =
+			// 	this.implicitGlobalResources.get(
+			// 		step.resourceType as
+			// 			| InfrastructureResourceType.CompiledLocalCodebase
+			// 			| InfrastructureResourceType.CloudHostedCodebase
+			// 	) || this.explicitResources.get(step.resource.resourceId);
+
+			const newStepInstance = new PublicationStep(
+				step.stepType,
+				step.id,
+				step.resourceType as InfrastructureResourceType,
+				step.status,
+				dependencies,
+				step.index,
+				// @ts-ignore
+				step.createdAt || emittedAt,
+				this,
+				null
+			);
+
+			newStepInstance.startedAt = step.startedAt || null;
+			newStepInstance.updatedAt = step.updatedAt || null;
+			newStepInstance.createdAt = step.createdAt || null;
+
+			this.steps.push(newStepInstance);
+		}
+	}
+
+	onUpdate(message: ILiveMessageDTO) {
+		Logger.log('onUpdate', message);
+
+		if (!!(message.payload as IDeploymentStepDefinition)?.stepType) {
+			// Update the step state
+			const step = this.steps.find(
+				(s) =>
+					s.id === (message.payload as IDeploymentStepDefinition)?.id
+			);
+
+			if (
+				step &&
+				dayjs(message.emittedAt).isAfter(dayjs(step.lastEventTimestamp))
+			) {
+				step.update(message.payload as IDeploymentStepDefinition);
+				step.lastEventTimestamp = message.emittedAt;
+			}
+		}
+
+		if (message.payload?.publishingSequence) {
+			// Update steps from the sequence
+			this.steps.forEach((step) => {
+				const stepInSequence = (
+					message.payload
+						.publishingSequence as IDeploymentStepDefinition[]
+				).find((s) => s.id === step.id);
+
+				if (stepInSequence) {
+					step.update(stepInSequence);
+				}
+			});
+		}
+
+		this.editor.emit('publication-updated', {});
+
+		if (message.type === LiveMessageEventType.Error) {
+			window.alert(
+				`Error in step ${message.payload.stepType}: ${message.payload.resourceId}`
+			);
+			this.finalStatus = PublicationStatus.Failed;
+			this.finalGlobalEvent =
+				message.event as ProjectPublicationEventName;
+			this.status = PublicationStatus.Failed;
+
+			this.editor.emit('project-publication-error', message);
+		} else if (message.type === LiveMessageEventType.Complete) {
+			this.finalStatus = PublicationStatus.Success;
+			this.finalGlobalEvent =
+				message.event as ProjectPublicationEventName;
+			this.status = PublicationStatus.Success;
+
+			this.editor.emit('project-publication-completed', message);
+		}
+	}
+
+	requestExtension<T = any>(moduleId: string): T {
+		return this.extensionsRegistry.requestExtension<T>(moduleId) as T;
+	}
+
+	async initRegistry(): Promise<
+		ExtensionsRegistry<any, any, any, PublicationRun>
+	> {
+		this.extensionsRegistry = new ExtensionsRegistry<
+			any,
+			any,
+			any,
+			PublicationRun
+		>(this.editor.events);
+		await this.extensionsRegistry.setup();
+
+		this.extensionsRegistry.onResolvePublicationRunContext(() => {
+			return this;
+		});
+
+		await this.extensionsRegistry.contextAvailable(
+			ExtensionContextType.PublicationRun
+		);
+
+		return this.extensionsRegistry;
+	}
+}