Update the template tables creation to use database tokens

packages/server/api/src/app/database/seeds/auto-instances-shutdown-table-seed.ts

@@ -6,7 +6,6 @@ import {
   SEED_OPENOPS_AUTO_INSTANCES_SHUTDOWN_TABLE_NAME,
 } from '../../openops-tables/template-tables/create-auto-instances-shutdown-table';
 import { databaseConnection } from '../database-connection';
-import { getDefaultProjectTablesDatabaseToken } from '../get-default-user-db-token';
 import { getAdminTablesContext } from './get-admin-token-and-database';
 
 const AUTO_INSTANCES_SHUTDOWN_TABLE_SEED = 'AUTOINSTANCESSHUTDOWN';
@@ -36,13 +35,13 @@ export const seedAutoInstancesShutdownTable = async (): Promise<void> => {
     return;
   }
 
+  const tablesContext = await getAdminTablesContext();
   const table = await getTableByName(
     SEED_OPENOPS_AUTO_INSTANCES_SHUTDOWN_TABLE_NAME,
-    await getDefaultProjectTablesDatabaseToken(),
+    tablesContext,
   );
 
   if (!table) {
-    const tablesContext = await getAdminTablesContext();
     await createAutoInstancesShutdownTable(tablesContext);
   }
 

packages/server/api/src/app/database/seeds/get-admin-token-and-database.ts

@@ -1,7 +1,6 @@
+import { TablesServerContext } from '@openops/common';
 import { AppSystemProp, system } from '@openops/server-shared';
 import { Project } from '@openops/shared';
-import { authenticateAdminUserInOpenOpsTables } from '../../openops-tables/auth-admin-tables';
-import { TablesContext } from '../../openops-tables/template-tables/types';
 import { projectService } from '../../project/project-service';
 import { userService } from '../../user/user-service';
 
@@ -25,8 +24,8 @@ const getAdminUserProject = async (): Promise<Project> => {
   return project;
 };
 
-export const getAdminTablesContext = async (): Promise<TablesContext> => {
-  const { token } = await authenticateAdminUserInOpenOpsTables();
-  const { tablesDatabaseId } = await getAdminUserProject();
-  return { token, tablesDatabaseId };
+export const getAdminTablesContext = async (): Promise<TablesServerContext> => {
+  const { tablesDatabaseId, tablesDatabaseToken } = await getAdminUserProject();
+
+  return { tablesDatabaseToken, tablesDatabaseId };
 };

packages/server/api/src/app/database/seeds/openops-aggregated-costs-seed.ts

@@ -6,7 +6,6 @@ import {
   SEED_TABLE_NAME,
 } from '../../openops-tables/template-tables/create-aggregated-costs-table';
 import { databaseConnection } from '../database-connection';
-import { getDefaultProjectTablesDatabaseToken } from '../get-default-user-db-token';
 import { getAdminTablesContext } from './get-admin-token-and-database';
 
 const AGGREGATED_TABLE_SEED = 'AGGREGATEDCOSTS';
@@ -35,13 +34,10 @@ export const seedFocusDataAggregationTemplateTable =
       return;
     }
 
-    const table = await getTableByName(
-      SEED_TABLE_NAME,
-      await getDefaultProjectTablesDatabaseToken(),
-    );
+    const tablesContext = await getAdminTablesContext();
+    const table = await getTableByName(SEED_TABLE_NAME, tablesContext);
 
     if (!table) {
-      const tablesContext = await getAdminTablesContext();
       await createAggregatedCostsTable(tablesContext);
     }
 

packages/server/api/src/app/database/seeds/openops-known-cost-types-by-application-seed.ts

@@ -6,7 +6,6 @@ import {
   SEED_OPENOPS_KNOWN_COST_TYPES_BY_APPLICATION_TABLE_NAME,
 } from '../../openops-tables/template-tables/create-known-cost-types-by-application-table';
 import { databaseConnection } from '../database-connection';
-import { getDefaultProjectTablesDatabaseToken } from '../get-default-user-db-token';
 import { getAdminTablesContext } from './get-admin-token-and-database';
 
 const KNOWN_COST_TYPES_BY_APPLICATION = 'KNOWNCOSTTYPES';
@@ -36,13 +35,13 @@ export const seedKnownCostTypesByApplicationTable = async (): Promise<void> => {
     return;
   }
 
+  const tablesContext = await getAdminTablesContext();
   const table = await getTableByName(
     SEED_OPENOPS_KNOWN_COST_TYPES_BY_APPLICATION_TABLE_NAME,
-    await getDefaultProjectTablesDatabaseToken(),
+    tablesContext,
   );
 
   if (!table) {
-    const tablesContext = await getAdminTablesContext();
     await createKnownCostTypesByApplicationTable(tablesContext);
   }
 

packages/server/api/src/app/helper/system-jobs/common.ts

@@ -1,3 +1,4 @@
+import { TablesServerContext } from '@openops/common';
 import { ProjectId } from '@openops/shared';
 import { Dayjs } from 'dayjs';
 
@@ -23,11 +24,6 @@ type IssuesReminderSystemJobData = {
   organizationId: string;
 };
 
-export type CreateTemplateTablesSystemJobData = {
-  tablesDatabaseId: number;
-  userId: string;
-};
-
 type SystemJobDataMap = {
   [SystemJobName.HARD_DELETE_PROJECT]: HardDeleteProjectSystemJobData;
   [SystemJobName.ISSUES_REMINDER]: IssuesReminderSystemJobData;
@@ -38,7 +34,7 @@ type SystemJobDataMap = {
   [SystemJobName.TRIAL_TRACKER]: Record<string, never>;
   [SystemJobName.TRIGGER_DATA_CLEANER]: Record<string, never>;
   [SystemJobName.LOGS_CLEANUP_TRIGGER]: Record<string, never>;
-  [SystemJobName.CREATE_TEMPLATE_TABLES]: CreateTemplateTablesSystemJobData;
+  [SystemJobName.CREATE_TEMPLATE_TABLES]: TablesServerContext;
 };
 
 export type SystemJobData<T extends SystemJobName = SystemJobName> =

packages/server/api/src/app/openops-tables/create-table.ts

@@ -1,4 +1,9 @@
-import { createAxiosHeaders, makeOpenOpsTablesPost } from '@openops/common';
+import {
+  createAxiosHeaders,
+  makeOpenOpsTablesPost,
+  resolveTokenProvider,
+  TablesServerContext,
+} from '@openops/common';
 
 export type Table = {
   id: number;
@@ -8,20 +13,20 @@ export type Table = {
 };
 
 export async function createTable(
-  databaseId: number,
+  context: TablesServerContext,
   tableName: string,
   tableColumns: string[][],
-  token: string,
 ): Promise<Table> {
   const requestBody = {
     name: tableName,
     data: tableColumns,
     first_row_header: true,
   };
 
+  const tokenOrResolver = await resolveTokenProvider(context);
   return makeOpenOpsTablesPost<Table>(
-    `api/database/tables/database/${databaseId}/`,
+    `api/database/tables/database/${context.tablesDatabaseId}/`,
     requestBody,
-    createAxiosHeaders(token),
+    createAxiosHeaders(tokenOrResolver),
   );
 }

packages/server/api/src/app/openops-tables/template-tables/create-aggregated-costs-table.ts

@@ -4,28 +4,29 @@ import {
   getPrimaryKeyFieldFromFields,
   makeOpenOpsTablesPatch,
   makeOpenOpsTablesPost,
+  resolveTokenProvider,
+  TablesServerContext,
+  TokenOrResolver,
 } from '@openops/common';
 import { logger } from '@openops/server-shared';
 import { openopsTables } from '../index';
-import { TablesContext } from './types';
 
 export const SEED_TABLE_NAME = 'Aggregated Costs';
 const SEED_LOG_HEADER = `[Seeding ${SEED_TABLE_NAME} table]`;
 
-export async function createAggregatedCostsTable({
-  token,
-  tablesDatabaseId,
-}: TablesContext): Promise<{ tableId: number }> {
+export async function createAggregatedCostsTable(
+  tablesContext: TablesServerContext,
+): Promise<{ tableId: number }> {
   logger.debug(`${SEED_LOG_HEADER} Start`);
 
   const table = await openopsTables.createTable(
-    tablesDatabaseId,
+    tablesContext,
     SEED_TABLE_NAME,
     [['Group Key']],
-    token,
   );
 
-  await addFields(token, table.id);
+  const tokenOrResolver = await resolveTokenProvider(tablesContext);
+  await addFields(tokenOrResolver, table.id);
 
   logger.debug(`${SEED_LOG_HEADER} Done`);
 
@@ -34,8 +35,11 @@ export async function createAggregatedCostsTable({
   };
 }
 
-export async function addFields(token: string, tableId: number) {
-  const fields = await getFields(tableId, token);
+export async function addFields(
+  tokenOrResolver: TokenOrResolver,
+  tableId: number,
+): Promise<void> {
+  const fields = await getFields(tableId, tokenOrResolver);
   const primaryField = getPrimaryKeyFieldFromFields(fields);
 
   logger.debug(
@@ -47,7 +51,7 @@ export async function addFields(token: string, tableId: number) {
       name: 'Group Key',
       type: 'text',
     },
-    createAxiosHeaders(token),
+    createAxiosHeaders(tokenOrResolver),
   );
   logger.debug(
     `${SEED_LOG_HEADER} After adding primary field ${primaryField.name} with id: ${primaryField.id}`,
@@ -66,12 +70,12 @@ export async function addFields(token: string, tableId: number) {
   ];
 
   for (const field of fieldsToAdd) {
-    await addField(token, tableId, field);
+    await addField(tokenOrResolver, tableId, field);
   }
 }
 
 async function addField(
-  token: string,
+  tokenOrResolver: TokenOrResolver,
   tableId: number,
   fieldBody: Record<string, unknown>,
 ): Promise<{ id: number }> {
@@ -82,7 +86,7 @@ async function addField(
   const field = await makeOpenOpsTablesPost<{ id: number }>(
     createFieldEndpoint,
     fieldBody,
-    createAxiosHeaders(token),
+    createAxiosHeaders(tokenOrResolver),
   );
 
   logger.debug(

packages/server/api/src/app/openops-tables/template-tables/create-all-template-tables.ts

@@ -1,13 +1,13 @@
+import { TablesServerContext } from '@openops/common';
 import { logger } from '@openops/server-shared';
 import { createAggregatedCostsTable } from './create-aggregated-costs-table';
 import { createAutoInstancesShutdownTable } from './create-auto-instances-shutdown-table';
 import { createBaseTemplateTables } from './create-base-template-tables';
 import { createKnownCostTypesByApplicationTable } from './create-known-cost-types-by-application-table';
 import { createOpportunitiesTable } from './create-opportunities-table';
-import { TablesContext } from './types';
 
 async function additionalTemplateTables(
-  tablesContext: TablesContext,
+  tablesContext: TablesServerContext,
 ): Promise<void> {
   await createOpportunitiesTable(tablesContext);
   await createAggregatedCostsTable(tablesContext);
@@ -17,7 +17,7 @@ async function additionalTemplateTables(
 }
 
 export async function createAllTemplateTables(
-  tablesContext: TablesContext,
+  tablesContext: TablesServerContext,
 ): Promise<void> {
   await createBaseTemplateTables(tablesContext);
   await additionalTemplateTables(tablesContext);

packages/server/api/src/app/openops-tables/template-tables/create-auto-instances-shutdown-table.ts

@@ -4,30 +4,31 @@ import {
   getPrimaryKeyFieldFromFields,
   makeOpenOpsTablesPatch,
   makeOpenOpsTablesPost,
+  resolveTokenProvider,
+  TablesServerContext,
+  TokenOrResolver,
 } from '@openops/common';
 import { logger } from '@openops/server-shared';
 import { createTable } from '../create-table';
-import { TablesContext } from './types';
 
 export const SEED_OPENOPS_AUTO_INSTANCES_SHUTDOWN_TABLE_NAME =
   'Auto instances shutdown';
 
-export async function createAutoInstancesShutdownTable({
-  token,
-  tablesDatabaseId,
-}: TablesContext): Promise<void> {
+export async function createAutoInstancesShutdownTable(
+  tablesContext: TablesServerContext,
+): Promise<void> {
   logger.debug(
     `[Seeding ${SEED_OPENOPS_AUTO_INSTANCES_SHUTDOWN_TABLE_NAME} table] Start`,
   );
 
   const table = await createTable(
-    tablesDatabaseId,
+    tablesContext,
     SEED_OPENOPS_AUTO_INSTANCES_SHUTDOWN_TABLE_NAME,
     [['Resource ID']],
-    token,
   );
 
-  const fields = await getFields(table.id, token);
+  const tokenOrResolver = await resolveTokenProvider(tablesContext);
+  const fields = await getFields(table.id, tokenOrResolver);
   const primaryField = getPrimaryKeyFieldFromFields(fields);
 
   logger.debug(
@@ -39,13 +40,13 @@ export async function createAutoInstancesShutdownTable({
       name: 'Resource ID',
       type: 'text',
     },
-    createAxiosHeaders(token),
+    createAxiosHeaders(tokenOrResolver),
   );
   logger.debug(
     `[Seeding ${SEED_OPENOPS_AUTO_INSTANCES_SHUTDOWN_TABLE_NAME} table] After adding primary field ID with id: ${primaryField.id}`,
   );
 
-  await addField(token, table.id, {
+  await addField(tokenOrResolver, table.id, {
     name: 'Shutdown time',
     type: 'date',
     date_format: 'ISO',
@@ -55,7 +56,10 @@ export async function createAutoInstancesShutdownTable({
   const fieldNames = ['Cloud provider', 'Workflow', 'Status'];
 
   for (const fieldName of fieldNames) {
-    await addField(token, table.id, { name: fieldName, type: 'text' });
+    await addField(tokenOrResolver, table.id, {
+      name: fieldName,
+      type: 'text',
+    });
   }
 
   logger.debug(
@@ -64,7 +68,7 @@ export async function createAutoInstancesShutdownTable({
 }
 
 async function addField(
-  token: string,
+  tokenOrResolver: TokenOrResolver,
   tableId: number,
   fieldBody: Record<string, unknown>,
 ): Promise<{ id: number }> {
@@ -77,7 +81,7 @@ async function addField(
   const field = await makeOpenOpsTablesPost<{ id: number }>(
     createFieldEndpoint,
     fieldBody,
-    createAxiosHeaders(token),
+    createAxiosHeaders(tokenOrResolver),
   );
 
   logger.debug(

packages/server/api/src/app/openops-tables/template-tables/create-base-template-tables.ts

@@ -1,22 +1,17 @@
+import { TablesServerContext } from '@openops/common';
 import { logger } from '@openops/server-shared';
 import { createBusinessUnitsTable } from './create-business-units-table';
 import { createIdleEbsVolumesToDeleteTable } from './create-idle-ebs-volumes-to-delete-table';
 import { createResourceBuTagAssignmentTable } from './create-resource-bu-tag-assignment-table';
 import { createTagOwnerMappingTable } from './create-tag-owner-mapping-table';
-import { TablesContext } from './types';
 
-export async function createBaseTemplateTables({
-  token,
-  tablesDatabaseId,
-}: TablesContext): Promise<void> {
-  const buTable = await createBusinessUnitsTable(tablesDatabaseId, token);
-  await createTagOwnerMappingTable(tablesDatabaseId, token, buTable.tableId);
-  await createIdleEbsVolumesToDeleteTable(tablesDatabaseId, token);
-  await createResourceBuTagAssignmentTable(
-    tablesDatabaseId,
-    token,
-    buTable.tableId,
-  );
+export async function createBaseTemplateTables(
+  tablesContext: TablesServerContext,
+): Promise<void> {
+  const buTable = await createBusinessUnitsTable(tablesContext);
+  await createTagOwnerMappingTable(tablesContext, buTable.tableId);
+  await createIdleEbsVolumesToDeleteTable(tablesContext);
+  await createResourceBuTagAssignmentTable(tablesContext, buTable.tableId);
 
   logger.info('[Seeding template tables] Done');
 }