fix style, add error types

SudoPub · Oct 14, 2023 · 95d9cb2 · 95d9cb2
1 parent 01d0072
commit 95d9cb2
Show file tree

Hide file tree

Showing 3 changed files with 73 additions and 34 deletions.
diff --git a/src/error/execute/configuration/connection-not-found.ts b/src/error/execute/configuration/connection-not-found.ts
@@ -8,7 +8,7 @@ import { PubExecuteConfigurationError } from "./configuration-error";
 
 export class PubExecuteConfigurationConnectionNotFoundError extends PubExecuteConfigurationError {
 
-    public static create(
+    public static withIdentifier(
         connectionIdentifier: string,
     ): PubExecuteConfigurationConnectionNotFoundError {
 

diff --git a/src/error/execute/configuration/procedure-not-found.ts b/src/error/execute/configuration/procedure-not-found.ts
@@ -0,0 +1,29 @@
+/**
+ * @author WMXPY
+ * @namespace Error_Execute_Configuration
+ * @description Procedure Not Found
+ */
+
+import { PubExecuteConfigurationError } from "./configuration-error";
+
+export class PubExecuteConfigurationProcedureNotFoundError extends PubExecuteConfigurationError {
+
+    public static withIdentifier(
+        procedureIdentifier: string,
+    ): PubExecuteConfigurationProcedureNotFoundError {
+
+        return new PubExecuteConfigurationProcedureNotFoundError(
+            `Procedure "${procedureIdentifier}" not found`,
+        );
+    }
+
+    protected constructor(
+        message: string,
+        reason?: any,
+    ) {
+
+        super(message, "PubExecuteConfigurationProcedureNotFoundError", reason);
+
+        Object.setPrototypeOf(this, PubExecuteConfigurationProcedureNotFoundError.prototype);
+    }
+}
diff --git a/src/execute/resume-execute.ts b/src/execute/resume-execute.ts
@@ -7,6 +7,7 @@
 import { PUB_CONNECTION_TYPE, PubConnectionConfiguration } from "../connection/definition/configuration";
 import { PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE, PubConnectionProcedureReference } from "../connection/definition/procedure-reference";
 import { PubExecuteConfigurationConnectionNotFoundError } from "../error/execute/configuration/connection-not-found";
+import { PubExecuteConfigurationProcedureNotFoundError } from "../error/execute/configuration/procedure-not-found";
 import { OrchestrationResourceManager } from "../orchestration/resource/manager";
 import { PUB_PROCEDURE_TYPE, PubProcedureConfiguration } from "../procedure/definition/configuration";
 import { PubRecordProjection } from "../record/definition/projection";
@@ -22,39 +23,48 @@ export const resumeExecute = async (
     for (const projection of projections) {
 
         const connections: Array<PubConnectionConfiguration<PUB_CONNECTION_TYPE>> =
-            projection.triggerConnections.map((
-                connectionIdentifier: string,
-            ) => {
-                const connection: PubConnectionConfiguration<PUB_CONNECTION_TYPE> | null =
-                    record.cachedConfiguration.getConnectionByIdentifier(connectionIdentifier);
-
-                if (!connection) {
-                    throw PubExecuteConfigurationConnectionNotFoundError.create(connectionIdentifier);
-                }
-
-                return connection;
-            });
-
-        const dependencyProcedures = connections
-            .filter((connection: PubConnectionConfiguration<PUB_CONNECTION_TYPE>) => connection.nextProcedure.type === PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE.PROCEDURE)
-            .map((connection: PubConnectionConfiguration<PUB_CONNECTION_TYPE>) => {
-
-                const nextProcedure: PubConnectionProcedureReference<
-                    PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE.PROCEDURE
-                > = connection.nextProcedure as PubConnectionProcedureReference<
-                    PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE.PROCEDURE
-                >;
-
-                const procedure: PubProcedureConfiguration<PUB_PROCEDURE_TYPE> | null = record.cachedConfiguration.getProcedureByIdentifier(
-                    nextProcedure.payload.procedureIdentifier,
-                );
-
-                if (!procedure) {
-                    throw PubExecuteConfigurationConnectionNotFoundError.create(nextProcedure.payload.procedureIdentifier);
-                }
-
-                return procedure;
-            });
+            projection.triggerConnections
+                .map((
+                    connectionIdentifier: string,
+                ) => {
+                    const connection: PubConnectionConfiguration<PUB_CONNECTION_TYPE> | null =
+                        record.cachedConfiguration.getConnectionByIdentifier(connectionIdentifier);
+
+                    if (!connection) {
+                        throw PubExecuteConfigurationConnectionNotFoundError.withIdentifier(
+                            connectionIdentifier,
+                        );
+                    }
+
+                    return connection;
+                });
+
+        const dependencyProcedures =
+            connections
+                .filter((connection: PubConnectionConfiguration<PUB_CONNECTION_TYPE>) =>
+                    connection.nextProcedure.type === PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE.PROCEDURE,
+                )
+                .map((connection: PubConnectionConfiguration<PUB_CONNECTION_TYPE>) => {
+
+                    const nextProcedure: PubConnectionProcedureReference<
+                        PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE.PROCEDURE
+                    > = connection.nextProcedure as PubConnectionProcedureReference<
+                        PUB_CONNECTION_PROCEDURE_REFERENCE_TYPE.PROCEDURE
+                    >;
+
+                    const procedure: PubProcedureConfiguration<PUB_PROCEDURE_TYPE> | null =
+                        record.cachedConfiguration.getProcedureByIdentifier(
+                            nextProcedure.payload.procedureIdentifier,
+                        );
+
+                    if (!procedure) {
+                        throw PubExecuteConfigurationProcedureNotFoundError.withIdentifier(
+                            nextProcedure.payload.procedureIdentifier,
+                        );
+                    }
+
+                    return procedure;
+                });
 
         console.log(connections, dependencyProcedures);
     }