Add tablesDatabaseId and tablesDatabaseToken to block context to be later used by openops-tables (#1647)

Part of OPS-3021.

Author: cezudas

packages/blocks/framework/src/lib/context.ts

@@ -1,5 +1,6 @@
 import {
   AppConnectionValue,
+  EncryptedObject,
   ExecutionType,
   FlowRunId,
   PauseMetadata,
@@ -125,6 +126,8 @@ export type ServerContext = {
   apiUrl: string;
   publicUrl: string;
   token: string;
+  tablesDatabaseId: number;
+  tablesDatabaseToken: EncryptedObject;
 };
 export type BaseActionContext<
   ET extends ExecutionType,

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

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

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

@@ -1,4 +1,5 @@
 import {
+  EncryptedObject,
   ExecuteFlowOperation,
   ExecutePropsOptions,
   ExecuteStepOperation,
@@ -38,8 +39,6 @@ export class EngineConstants {
   public static readonly BLOCK_SOURCES =
     process.env.OPS_BLOCKS_SOURCE ?? 'FILE';
 
-  private project: Project | null = null;
-
   public get baseCodeDirectory(): string {
     return EngineConstants.BASE_CODE_DIRECTORY;
   }
@@ -67,12 +66,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 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,
@@ -96,15 +102,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,
@@ -128,12 +141,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,
@@ -157,12 +177,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,
@@ -186,24 +213,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,6 +124,8 @@ export const blockHelper = {
           token: params.engineToken,
           apiUrl: constants.internalApiUrl,
           publicUrl: params.publicUrl,
+          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);
   });