Ensure project is fetched during EngineConstants factory initialization

Author: cezudas

packages/engine/src/lib/handler/block-executor.ts

@@ -189,8 +189,8 @@ const executeAction: ActionHandler<BlockAction> = async ({
         token: constants.engineToken,
         apiUrl: constants.internalApiUrl,
         publicUrl: constants.publicUrl,
-        tablesDatabaseId: await constants.getTablesDatabaseId(),
-        tablesDatabaseToken: await constants.getTablesDatabaseToken(),
+        tablesDatabaseId: constants.tablesDatabaseId,
+        tablesDatabaseToken: constants.tablesDatabaseToken,
       },
       propsValue: processedInput,
       tags: createTagsManager(hookResponse),

packages/engine/src/lib/handler/context/engine-constants.ts

@@ -68,22 +68,19 @@ export class EngineConstants {
     public readonly serverHandlerId: string | null,
     public readonly testRunActionLimits: TestRunLimitSettings,
     public readonly isTestRun: boolean,
+    public readonly tablesDatabaseId: number,
+    public readonly tablesDatabaseToken: EncryptedObject,
     public readonly resumePayload?: ResumePayload,
   ) {}
 
-  public async getTablesDatabaseId(): Promise<number> {
-    const project = await this.getProject();
-    return project.tablesDatabaseId;
-  }
-
-  public async getTablesDatabaseToken(): Promise<EncryptedObject> {
-    const project = await this.getProject();
-    return project.tablesDatabaseToken;
-  }
-
-  public static fromExecuteFlowInput(
+  public static async fromExecuteFlowInput(
     input: ExecuteFlowOperation,
-  ): EngineConstants {
+  ): Promise<EngineConstants> {
+    const project = await EngineConstants.fetchProject(
+      input.internalApiUrl,
+      input.engineToken,
+    );
+
     return new EngineConstants(
       input.executionCorrelationId,
       input.flowVersion.flowId,
@@ -107,15 +104,22 @@ export class EngineConstants {
       input.serverHandlerId ?? null,
       input.flowVersion.testRunActionLimits,
       input.runEnvironment === 'TESTING',
+      project.tablesDatabaseId,
+      project.tablesDatabaseToken,
       input.executionType === ExecutionType.RESUME
         ? input.resumePayload
         : undefined,
     );
   }
 
-  public static fromExecuteStepInput(
+  public static async fromExecuteStepInput(
     input: ExecuteStepOperation,
-  ): EngineConstants {
+  ): Promise<EngineConstants> {
+    const project = await EngineConstants.fetchProject(
+      input.internalApiUrl,
+      input.engineToken,
+    );
+
     return new EngineConstants(
       null,
       input.flowVersion.flowId,
@@ -139,12 +143,19 @@ export class EngineConstants {
       null,
       input.flowVersion.testRunActionLimits,
       true,
+      project.tablesDatabaseId,
+      project.tablesDatabaseToken,
     );
   }
 
-  public static fromExecutePropertyInput(
+  public static async fromExecutePropertyInput(
     input: ExecutePropsOptions,
-  ): EngineConstants {
+  ): Promise<EngineConstants> {
+    const project = await EngineConstants.fetchProject(
+      input.internalApiUrl,
+      input.engineToken,
+    );
+
     return new EngineConstants(
       null,
       input.flowVersion.flowId,
@@ -168,12 +179,19 @@ export class EngineConstants {
       null,
       input.flowVersion.testRunActionLimits,
       true,
+      project.tablesDatabaseId,
+      project.tablesDatabaseToken,
     );
   }
 
-  public static fromExecuteTriggerInput(
+  public static async fromExecuteTriggerInput(
     input: ExecuteTriggerOperation<TriggerHookType>,
-  ): EngineConstants {
+  ): Promise<EngineConstants> {
+    const project = await EngineConstants.fetchProject(
+      input.internalApiUrl,
+      input.engineToken,
+    );
+
     return new EngineConstants(
       null,
       input.flowVersion.flowId,
@@ -197,24 +215,26 @@ export class EngineConstants {
       null,
       input.flowVersion.testRunActionLimits,
       input.test,
+      project.tablesDatabaseId,
+      project.tablesDatabaseToken,
     );
   }
 
-  private async getProject(): Promise<Project> {
-    if (this.project) {
-      return this.project;
-    }
-
-    const getWorkerProjectEndpoint = `${this.internalApiUrl}v1/worker/project`;
+  private static async fetchProject(
+    internalApiUrl: string,
+    engineToken: string,
+  ): Promise<Project> {
+    const getWorkerProjectEndpoint = `${addTrailingSlashIfMissing(
+      internalApiUrl,
+    )}v1/worker/project`;
 
     const response = await fetch(getWorkerProjectEndpoint, {
       headers: {
-        Authorization: `Bearer ${this.engineToken}`,
+        Authorization: `Bearer ${engineToken}`,
       },
     });
 
-    this.project = (await response.json()) as Project;
-    return this.project;
+    return (await response.json()) as Project;
   }
 }
 

packages/engine/src/lib/helper/block-helper.ts

@@ -124,8 +124,8 @@ export const blockHelper = {
           token: params.engineToken,
           apiUrl: constants.internalApiUrl,
           publicUrl: params.publicUrl,
-          tablesDatabaseId: await constants.getTablesDatabaseId(),
-          tablesDatabaseToken: await constants.getTablesDatabaseToken(),
+          tablesDatabaseId: constants.tablesDatabaseId,
+          tablesDatabaseToken: constants.tablesDatabaseToken,
         },
         project: {
           id: params.projectId,

packages/engine/src/lib/operations.ts

@@ -45,7 +45,7 @@ const executeFlow = async (
   context: FlowExecutorContext,
 ): Promise<EngineResponse<Pick<FlowRunResponse, 'status' | 'error'>>> => {
   try {
-    const constants = EngineConstants.fromExecuteFlowInput(input);
+    const constants = await EngineConstants.fromExecuteFlowInput(input);
 
     const response = await flowExecutor.triggerFlowExecutor({
       trigger: input.flowVersion.trigger,
@@ -92,7 +92,7 @@ async function executeStep(
       engineToken: input.engineToken,
       stepTestOutputs: input.stepTestOutputs,
     }),
-    constants: EngineConstants.fromExecuteStepInput(input),
+    constants: await EngineConstants.fromExecuteStepInput(input),
   });
 
   const stepResult = output.steps[step.name];
@@ -203,7 +203,7 @@ export async function execute(
             stepTestOutputs: input.stepTestOutputs,
           }),
           searchValue: input.searchValue,
-          constants: EngineConstants.fromExecutePropertyInput(input),
+          constants: await EngineConstants.fromExecutePropertyInput(input),
         });
 
         return {
@@ -222,7 +222,7 @@ export async function execute(
 
         const output = await triggerHelper.executeTrigger({
           params: input,
-          constants: EngineConstants.fromExecuteTriggerInput(input),
+          constants: await EngineConstants.fromExecuteTriggerInput(input),
         });
 
         return {

packages/engine/src/lib/resolve-variable.ts

@@ -9,7 +9,7 @@ export async function resolveVariable(
   input: ResolveVariableOperation,
 ): Promise<ResolveVariableResponse> {
   try {
-    const constants = EngineConstants.fromExecuteStepInput({
+    const constants = await EngineConstants.fromExecuteStepInput({
       projectId: input.projectId,
       engineToken: input.engineToken,
       internalApiUrl: input.internalApiUrl,

packages/engine/test/handler/test-helper.ts

@@ -30,6 +30,8 @@ export const generateMockEngineConstants = (params?: Partial<EngineConstants>):
         params?.serverHandlerId ?? null,
         params?.testRunActionLimits ?? { isEnabled: false, limits: [] },
         params?.isTestRun ?? false,
+        params?.tablesDatabaseId ?? 1,
+        params?.tablesDatabaseToken ?? { iv: 'test-iv', data: 'test-data' },
         params?.resumePayload,
     )
 }

packages/engine/test/resolve-variable.test.ts

@@ -60,7 +60,7 @@ describe('resolveVariable', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
-    mockEngineConstants.fromExecuteStepInput = jest.fn().mockReturnValue(mockConstants);
+    mockEngineConstants.fromExecuteStepInput = jest.fn().mockResolvedValue(mockConstants);
     mockTestExecutionContext.stateFromFlowVersion = jest.fn().mockResolvedValue(mockExecutionState);
   });