merge master

Author: pavelzotikov

convertors/set-user-project-last-visit.js

@@ -0,0 +1,53 @@
+require('dotenv').config();
+require('process');
+const { setup } = require('./setup');
+
+/**
+ * Method that runs convertor script
+ */
+async function run() {
+    const { client, hawkDb } = await setup();
+
+    const collections = await hawkDb.listCollections({}, {
+        authorizedCollections: true,
+        nameOnly: true,
+    }).toArray();
+
+    let usersInProjectCollectionsToCheck = collections.filter(col => /^users-in-project:/.test(col.name)).map(col => col.name);
+
+    console.log(`Found ${usersInProjectCollectionsToCheck.length} users in project collections.`);
+
+    const usersDocuments = await hawkDb.collection('users').find({}).toArray();
+
+    // Convert events
+    let i = 1;
+
+    for (const collectionName of usersInProjectCollectionsToCheck) {
+        console.log(`[${i}/${usersInProjectCollectionsToCheck.length}] Processing ${collectionName}`);
+
+        const usersInProject = await hawkDb.collection(collectionName).find({}).toArray();
+
+        console.log(`Found ${usersInProject.length} users in project ${collectionName}.`);
+
+        let usersUpdatedCount = 0;
+
+        for (const userInProject of usersInProject) {
+            const userDocument = usersDocuments.find(u => u._id.toString() === userInProject.userId.toString());
+            if (userDocument) {
+                const projectId = collectionName.split(':')[1];
+                await hawkDb.collection('users').updateOne({ _id: userDocument._id }, { $set: { [`projectsLastVisit.${projectId}`]: userInProject.timestamp } });
+                usersUpdatedCount++;
+                console.log(`Updated ${usersUpdatedCount}/${usersInProject.length} users in project ${collectionName}.`);
+            }
+        }
+
+        i++;
+    }
+
+    await client.close();
+}
+
+run().catch(err => {
+    console.error('❌ Script failed:', err);
+    process.exit(1);
+});

convertors/set-user-workspaces-membership.js

@@ -0,0 +1,53 @@
+require('dotenv').config();
+require('process');
+const { setup } = require('./setup');
+
+/**
+ * Method that runs convertor script
+ */
+async function run() {
+    const { client, hawkDb } = await setup();
+
+    const collections = await hawkDb.listCollections({}, {
+        authorizedCollections: true,
+        nameOnly: true,
+    }).toArray();
+
+    let usersMembershipCollectionsToCheck = collections.filter(col => /^membership:/.test(col.name)).map(col => col.name);
+
+    console.log(`Found ${usersMembershipCollectionsToCheck.length} users membership collections.`);
+
+    const usersDocuments = await hawkDb.collection('users').find({}).toArray();
+
+    let i = 1;
+
+    for (const collectionName of usersMembershipCollectionsToCheck) {
+        console.log(`[${i}/${usersMembershipCollectionsToCheck.length}] Processing ${collectionName}`);
+
+        const userId = collectionName.split(':')[1];
+
+        const userDocument = usersDocuments.find(u => u._id.toString() === userId);
+
+        if (!userDocument) {
+            i++;
+            continue;
+        }
+
+        const memberships = await hawkDb.collection(collectionName).find({}).toArray();
+
+        for (const membership of memberships) {
+            const workspaceId = membership.workspaceId.toString();
+            const isPending = membership.isPending || false;
+            await hawkDb.collection('users').updateOne({ _id: userDocument._id }, { $set: { [`workspaces.${workspaceId}`]: { isPending } } });
+        }
+
+        i++;
+    }
+
+    await client.close();
+}
+
+run().catch(err => {
+    console.error('❌ Script failed:', err);
+    process.exit(1);
+});

convertors/setup.js

@@ -0,0 +1,44 @@
+const { MongoClient } = require('mongodb');
+
+async function setup() {
+    const fullUri = process.env.MONGO_HAWK_DB_URL;
+
+    // Parse the Mongo URL manually
+    const mongoUrl = new URL(fullUri);
+    const hawkDatabaseName = 'hawk';
+
+    // Extract query parameters
+    const queryParams = Object.fromEntries(mongoUrl.searchParams.entries());
+
+    // Compose connection options manually
+    const options = {
+        useNewUrlParser: true,
+        useUnifiedTopology: true,
+        authSource: queryParams.authSource || 'admin',
+        replicaSet: queryParams.replicaSet || undefined,
+        tls: queryParams.tls === 'true',
+        tlsInsecure: queryParams.tlsInsecure === 'true',
+        // connectTimeoutMS: 3600000,
+        // socketTimeoutMS: 3600000,
+    };
+
+    // Remove query string from URI
+    mongoUrl.search = '';
+    const cleanUri = mongoUrl.toString();
+
+    console.log('Connecting to:', cleanUri);
+    console.log('With options:', options);
+
+    const client = new MongoClient(cleanUri, options);
+
+    await client.connect();
+    const hawkDb = client.db(hawkDatabaseName);
+
+    console.log(`Connected to database: ${hawkDatabaseName}`);
+
+    return { client, hawkDb };
+}
+
+module.exports = { setup };
+
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hawk.api",
-  "version": "1.2.14",
+  "version": "1.2.19",
   "main": "index.ts",
   "license": "BUSL-1.1",
   "scripts": {
@@ -11,6 +11,7 @@
     "dev:up": "docker-compose -f docker-compose.dev.yml up -d",
     "dev:down": "docker-compose -f docker-compose.dev.yml down",
     "build": "tsc",
+    "convert": "node ./convertors/set-user-project-last-visit.js",
     "migrations:create": "docker-compose exec api yarn migrate-mongo create",
     "migrations:up": "docker-compose exec api yarn migrate-mongo up",
     "migrations:down": "docker-compose exec api yarn migrate-mongo down",

src/index.ts

@@ -28,6 +28,7 @@ import schema from './schema';
 import { graphqlUploadExpress } from 'graphql-upload';
 import { metricsMiddleware, createMetricsServer, graphqlMetricsPlugin } from './metrics';
 import { requestLogger } from './utils/logger';
+import ReleasesFactory from './models/releasesFactory';
 
 /**
  * Option to enable playground
@@ -164,12 +165,16 @@ class HawkAPI {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const businessOperationsFactory = new BusinessOperationsFactory(mongo.databases.hawk!, dataLoaders);
 
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const releasesFactory = new ReleasesFactory(mongo.databases.events!);
+
     return {
       usersFactory,
       workspacesFactory,
       projectsFactory,
       plansFactory,
       businessOperationsFactory,
+      releasesFactory,
     };
   }
 

src/models/eventsFactory.js

@@ -196,6 +196,7 @@ class EventsFactory extends Factory {
    * @param {'BY_DATE' | 'BY_COUNT'} sort - events sort order
    * @param {EventsFilters} filters - marks by which events should be filtered
    * @param {String} search - Search query
+   * @param {String} release - release name
    *
    * @return {DaylyEventsPortionSchema}
    */
@@ -204,7 +205,8 @@ class EventsFactory extends Factory {
     paginationCursor = null,
     sort = 'BY_DATE',
     filters = {},
-    search = ''
+    search = '',
+    release
   ) {
     if (typeof search !== 'string') {
       throw new Error('Search parameter must be a string');
@@ -324,6 +326,25 @@ class EventsFactory extends Factory {
       )
       : {};
 
+    // Filter by release if provided (coerce event payload release to string)
+    const releaseFilter = release
+      ? {
+        $expr: {
+          $eq: [
+            {
+              $convert: {
+                input: '$event.payload.release',
+                to: 'string',
+                onError: '',
+                onNull: '',
+              },
+            },
+            String(release),
+          ],
+        },
+      }
+      : {};
+
     pipeline.push(
       /**
        * Left outer join original event on groupHash field
@@ -360,6 +381,7 @@ class EventsFactory extends Factory {
         $match: {
           ...matchFilter,
           ...searchFilter,
+          ...releaseFilter,
         },
       },
       { $limit: limit + 1 },

src/models/releasesFactory.ts

@@ -0,0 +1,99 @@
+// TODO: it would be great to move release logic from another factories/resolvers to this class
+import type { Collection, Db, ObjectId } from 'mongodb';
+import type { ReleaseDBScheme } from '@hawk.so/types';
+
+/**
+ * Interface representing how release files are stored in the DB
+ */
+export interface ReleaseFileDBScheme {
+  /**
+   * File's id
+   */
+  _id: ObjectId;
+
+  /**
+   * File length in bytes
+   */
+  length: number;
+
+  /**
+   * File upload date
+   */
+  uploadDate: Date;
+
+  /**
+   * File chunk size
+   */
+  chunkSize: number;
+
+  /**
+   * File map name
+   */
+  filename: string;
+
+  /**
+   * File MD5 hash
+   */
+  md5: string;
+}
+
+/**
+ * ReleasesFactory
+ * Helper for accessing releases collection
+ */
+export default class ReleasesFactory {
+  /**
+   * DataBase collection to work with
+   */
+  private readonly collection: Collection<ReleaseDBScheme>;
+  private readonly filesCollection: Collection<ReleaseFileDBScheme>;
+
+  /**
+   * Creates releases factory instance
+   * @param dbConnection - connection to Events DB
+   */
+  constructor(dbConnection: Db) {
+    this.collection = dbConnection.collection<ReleaseDBScheme>('releases');
+    this.filesCollection = dbConnection.collection<ReleaseFileDBScheme>('releases.files');
+  }
+
+  /**
+   * Find one release document by projectId and release label.
+   * Tries both exact string match and numeric fallback (if release can be cast to number).
+   */
+  public async findByProjectAndRelease(
+    projectId: string | ObjectId,
+    release: string
+  ): Promise<ReleaseDBScheme | null> {
+    const projectIdStr = projectId.toString();
+
+    // Try exact match as stored
+    let doc = await this.collection.findOne({
+      projectId: projectIdStr,
+      release: release as ReleaseDBScheme['release'],
+    });
+
+    // Fallback if release stored as number
+    if (!doc) {
+      const asNumber = Number(release);
+
+      if (!Number.isNaN(asNumber)) {
+        doc = await this.collection.findOne({
+          projectId: projectIdStr,
+          release: asNumber as unknown as ReleaseDBScheme['release'],
+        });
+      }
+    }
+
+    return doc;
+  }
+
+  /**
+   * Find files by file ids
+   * @param fileIds - file ids
+   * @returns files
+   */
+  public async findFilesByFileIds(fileIds: ObjectId[]): Promise<ReleaseFileDBScheme[]> {
+    return this.filesCollection.find({ _id: { $in: fileIds } }).toArray();
+  }
+}