feat: bundle opa version and auth-cron logs [MAPCO-7868] (#66)

* feat(auth-core): added opaVersion column

* feat(auth-manager): support the opa version bundle property

* feat(auth-bundler): added opaVersion to bundle

* fix(auth-bundler): added missing export to opa version command

* feat(auth-cron): added opa version to bundle

* refactor(auth-cron): added more logs

* test(auth-cron): update packages/auth-cron/tests/job.spec.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: CptSchnitz

package-lock.json

@@ -4,6 +4,7 @@ import { BundleContent, BundleContentVersions } from './types';
 import { extractNameAndVersion } from './util';
 import { logger } from './logger';
 import { ConnectionNotInitializedError, KeyNotFoundError } from './errors';
+import { getVersionCommand } from './opa';
 
 /**
  * This class handles all the database interactions required to creating a bundle.
@@ -60,6 +61,7 @@ export class BundleDatabase {
       connections: versions.connections,
       keyVersion: versions.keyVersion,
       hash,
+      opaVersion: await getVersionCommand(),
     };
 
     const res = await this.bundleRepository.save(bundle);

packages/auth-bundler/src/db.ts

@@ -18,6 +18,7 @@ export * from './errors';
 export { setLogger } from './logger';
 export { BundleDatabase } from './db';
 export * from './types';
+export { getVersionCommand } from './opa';
 
 /**
  * This function creates an opa bundle tarball from the given content

packages/auth-bundler/src/index.ts

@@ -79,3 +79,28 @@ export async function createBundleCommand(filesPath: string, bundlePath: string)
   }
   return [false, res.stdout];
 }
+
+/**
+ * Gets the OPA version from the CLI
+ * @returns The OPA version string (e.g., "0.52.0")
+ * @see {@link https://www.openpolicyagent.org/docs/latest/cli/#opa-version}
+ * @ignore
+ */
+export async function getVersionCommand(): Promise<string> {
+  const res = await execa('opa', ['version']);
+
+  // Extract version from first line: "Version: X.Y.Z"
+  const versionLine = res.stdout.split('\n')[0];
+
+  if (!versionLine) {
+    throw new Error('Unable to read OPA version output');
+  }
+
+  const versionMatch = versionLine.match(/Version:\s*(\d+\.\d+\.\d+)/);
+
+  if (!versionMatch || !versionMatch[1]) {
+    throw new Error('Unable to parse OPA version from output');
+  }
+
+  return versionMatch[1];
+}

packages/auth-bundler/src/opa.ts

@@ -1,14 +1,26 @@
 /// <reference types="jest-extended" />
 
-import { Asset, Connection, Environment, Key, createConnectionOptions } from '@map-colonies/auth-core';
+import { Asset, Bundle, Connection, Environment, Key, createConnectionOptions } from '@map-colonies/auth-core';
 import { DataSource } from 'typeorm';
 import { ConnectionNotInitializedError } from '@src';
 import { BundleDatabase } from '@src/db';
+import * as execa from '@src/wrappers/execa';
 import { getMockKeys } from './utils/key';
 import { getFakeAsset } from './utils/asset';
 import { getFakeConnection } from './utils/connection';
 import { getConfig, initConfig } from './helpers/config';
 
+jest.mock('../src/wrappers/execa', () => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    __esModule: true,
+    ...jest.requireActual('../src/wrappers/execa'),
+  };
+});
+
+type ExecaChildProcess = Awaited<ReturnType<(typeof execa)['execa']>>;
+
 describe('db.ts', function () {
   let dataSource: DataSource;
   const asset = { ...getFakeAsset(), environment: [Environment.PRODUCTION], name: 'aviaviavi' };
@@ -57,45 +69,58 @@ describe('db.ts', function () {
 
   describe('#saveBundle', function () {
     it('should save the bundle to the db', async function () {
+      const VERSION_OUTPUT = 'Version: 0.52.0\nBuild Commit: 8d2c137662560cac83d9cf24cbdaecc934910333\nBuild Timestamp: 2023-04-27T17:57:23Z';
+      jest.spyOn(execa, 'execa').mockResolvedValue({ stdout: VERSION_OUTPUT } as ExecaChildProcess);
+
       const db = new BundleDatabase(dataSource);
 
       const res = await db.saveBundle({ assets: [], connections: [], environment: Environment.PRODUCTION, keyVersion: 3 }, 'xdxd');
 
       expect(res).toBeGreaterThan(0);
+      const bundle = await dataSource.getRepository(Bundle).findOneByOrFail({ id: res });
+
+      expect(bundle).toMatchObject({
+        environment: Environment.PRODUCTION,
+        keyVersion: 3,
+        opaVersion: '0.52.0',
+        hash: 'xdxd',
+        assets: [],
+        connections: [],
+      });
     });
-  });
 
-  describe('#getLatestVersions', function () {
-    it('should fetch the latest versions from the database', async function () {
-      const db = new BundleDatabase(dataSource);
+    describe('#getLatestVersions', function () {
+      it('should fetch the latest versions from the database', async function () {
+        const db = new BundleDatabase(dataSource);
 
-      const { assets, connections, keyVersion } = await db.getLatestVersions(Environment.PRODUCTION);
+        const { assets, connections, keyVersion } = await db.getLatestVersions(Environment.PRODUCTION);
 
-      expect(keyVersion).toBe(1);
+        expect(keyVersion).toBe(1);
 
-      const asset = assets.filter((a) => a.name === 'aviaviavi');
-      expect(asset).toHaveLength(1);
-      expect(asset[0]).toHaveProperty('version', 2);
+        const asset = assets.filter((a) => a.name === 'aviaviavi');
+        expect(asset).toHaveLength(1);
+        expect(asset[0]).toHaveProperty('version', 2);
 
-      const connection = connections.filter((c) => c.name === 'xd');
-      expect(connection).toHaveLength(1);
-      expect(connection[0]).toHaveProperty('version', 2);
+        const connection = connections.filter((c) => c.name === 'xd');
+        expect(connection).toHaveLength(1);
+        expect(connection[0]).toHaveProperty('version', 2);
+      });
     });
-  });
 
-  describe('#getBundleFromVersions', function () {
-    it('should fetch the bundle content based on the versions from the database', async function () {
-      const db = new BundleDatabase(dataSource);
+    describe('#getBundleFromVersions', function () {
+      it('should fetch the bundle content based on the versions from the database', async function () {
+        const db = new BundleDatabase(dataSource);
 
-      const { assets } = await db.getBundleFromVersions({
-        environment: Environment.PRODUCTION,
-        assets: [{ name: 'aviaviavi', version: 1 }],
-        connections: [],
-        keyVersion: 1,
-      });
+        const { assets } = await db.getBundleFromVersions({
+          environment: Environment.PRODUCTION,
+          assets: [{ name: 'aviaviavi', version: 1 }],
+          connections: [],
+          keyVersion: 1,
+        });
 
-      expect(assets).toSatisfyAll<Asset>((a) => a.environment.includes(Environment.PRODUCTION));
-      expect(assets[0]).toHaveProperty('version', 1);
+        expect(assets).toSatisfyAll<Asset>((a) => a.environment.includes(Environment.PRODUCTION));
+        expect(assets[0]).toHaveProperty('version', 1);
+      });
     });
   });
 });

packages/auth-bundler/tests/db.spec.ts

@@ -2,7 +2,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { mkdir, writeFile } from 'node:fs/promises';
 import * as execa from '@src/wrappers/execa';
-import { checkFilesCommand, createBundleCommand, testCommand, testCoverageCommand, validateBinaryExistCommand } from '@src/opa';
+import { checkFilesCommand, createBundleCommand, getVersionCommand, testCommand, testCoverageCommand, validateBinaryExistCommand } from '@src/opa';
 
 jest.mock('../src/wrappers/execa', () => {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return
@@ -139,4 +139,33 @@ describe('opa.ts', function () {
       expect(err).toBe('oh no');
     });
   });
+
+  describe('#getVersionCommand', function () {
+    it('should return the version string when command succeeds', async function () {
+      const VERSION_OUTPUT = 'Version: 0.52.0\nBuild Commit: 8d2c137662560cac83d9cf24cbdaecc934910333\nBuild Timestamp: 2023-04-27T17:57:23Z';
+      jest.spyOn(execa, 'execa').mockResolvedValue({ stdout: VERSION_OUTPUT } as ExecaChildProcess);
+
+      const version = await getVersionCommand();
+
+      expect(version).toBe('0.52.0');
+    });
+
+    it('should throw error when output is empty', async function () {
+      jest.spyOn(execa, 'execa').mockResolvedValue({ stdout: '' } as ExecaChildProcess);
+
+      await expect(getVersionCommand()).rejects.toThrow('Unable to read OPA version output');
+    });
+
+    it('should throw error when output format is invalid', async function () {
+      jest.spyOn(execa, 'execa').mockResolvedValue({ stdout: 'Invalid output format' } as ExecaChildProcess);
+
+      await expect(getVersionCommand()).rejects.toThrow('Unable to parse OPA version from output');
+    });
+
+    it('should throw error when version line has no version', async function () {
+      jest.spyOn(execa, 'execa').mockResolvedValue({ stdout: 'Version: \nOther info' } as ExecaChildProcess);
+
+      await expect(getVersionCommand()).rejects.toThrow('Unable to parse OPA version from output');
+    });
+  });
 });

packages/auth-bundler/tests/opa.spec.ts

@@ -34,6 +34,7 @@ export function getFakeBundle(includeCreated?: boolean): IBundle {
     assets: [{ name: 'aaaa', version: 1 }],
     connections: [{ name: 'bbb', version: 2 }],
     metadata: { ccc: 123 },
+    opaVersion: '0.52.0',
   };
 }
 

packages/auth-bundler/tests/utils/bundle.ts

@@ -29,4 +29,7 @@ export class Bundle implements IBundle {
 
   @Column({ name: 'key_version', type: 'integer', nullable: true })
   public keyVersion?: number;
+
+  @Column({ name: 'opa_version', type: 'text', nullable: false })
+  public opaVersion!: string;
 }

packages/auth-core/src/db/entities/bundle.ts

@@ -0,0 +1,18 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddOpaVersionToBundle1749972920049 implements MigrationInterface {
+  public name = 'AddOpaVersionToBundle1749972920049';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Add the column as nullable first
+    await queryRunner.query(`ALTER TABLE "auth_manager"."bundle" ADD "opa_version" text`);
+    // Set default value for existing bundles
+    await queryRunner.query(`UPDATE "auth_manager"."bundle" SET "opa_version" = '0.52.0' WHERE "opa_version" IS NULL`);
+    // Make the column NOT NULL
+    await queryRunner.query(`ALTER TABLE "auth_manager"."bundle" ALTER COLUMN "opa_version" SET NOT NULL`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "auth_manager"."bundle" DROP COLUMN "opa_version"`);
+  }
+}

packages/auth-core/src/db/migrations/1749972920049-addOpaVersionToBundle.ts

@@ -20,4 +20,6 @@ export interface IBundle {
   createdAt?: Date;
   /** The version of the key that is part of the bundle. */
   keyVersion?: number;
+  /** The version of the OPA cli that was used to create the bundle. */
+  opaVersion: string;
 }