@powersync/service-module-postgres-storage 0.0.0-dev-20250724111728 → 0.0.0-dev-20250729121434

package/src/storage/PostgresReportStorageFactory.ts

@@ -1,6 +1,7 @@
 import { storage } from '@powersync/service-core';
 import * as pg_wire from '@powersync/service-jpgwire';
-
+import { event_types } from '@powersync/service-types';
+import { v4 } from 'uuid';
 import * as lib_postgres from '@powersync/lib-service-postgres';
 import { NormalizedPostgresStorageConfig } from '../types/types.js';
 
@@ -21,8 +22,6 @@ export type PostgresReportStorageOptions = {
 
 export class PostgresReportStorageFactory implements storage.ReportStorageFactory {
   readonly db: lib_postgres.DatabaseClient;
-  private activeStorage: storage.SyncRulesBucketStorage | undefined;
-
   constructor(protected options: PostgresReportStorageOptions) {
     this.db = new lib_postgres.DatabaseClient({
       config: options.config,
@@ -34,20 +33,274 @@ export class PostgresReportStorageFactory implements storage.ReportStorageFactor
       connectionCreated: async (connection) => this.prepareStatements(connection)
     });
   }
-  reportSdkConnect(data: SdkConnectBucketData): Promise<void> {
-    throw new Error('Method not implemented.');
+
+  private parseJsDate(date: Date) {
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    const today = date.getDate();
+    const day = date.getDay();
+    return {
+      year,
+      month,
+      today,
+      day,
+      parsedDate: date
+    };
+  }
+  private timeFrameQuery(timeframe: event_types.TimeFrames, interval: number = 1) {
+    const { year, month, today, parsedDate } = this.parseJsDate(new Date());
+    switch (timeframe) {
+      case 'month': {
+        return { lt: parsedDate.toISOString(), gt: new Date(year, parsedDate.getMonth() - interval).toISOString() };
+      }
+      case 'week': {
+        const weekStartDate = new Date(parsedDate);
+        weekStartDate.setDate(weekStartDate.getDate() - 6 * interval);
+        const weekStart = this.parseJsDate(weekStartDate);
+        return {
+          lt: parsedDate.toISOString(),
+          gt: new Date(weekStart.year, weekStart.month, weekStart.today).toISOString()
+        };
+      }
+      case 'hour': {
+        // Get the last hour from the current time
+        const previousHour = parsedDate.getHours() - interval;
+        return {
+          lt: new Date(year, month, today, parsedDate.getHours()).toISOString(),
+          gt: new Date(year, month, today, previousHour).toISOString()
+        };
+      }
+      default: {
+        return {
+          lt: parsedDate.toISOString(),
+          gt: new Date(year, month, today - interval).toISOString()
+        };
+      }
+    }
+  }
+
+  private timeFrameDeleteQuery(timeframe: event_types.TimeFrames, interval: number = 1) {
+    const { year, month, today, parsedDate } = this.parseJsDate(new Date());
+    switch (timeframe) {
+      case 'month': {
+        return { lt: new Date(year, parsedDate.getMonth() - interval).toISOString() };
+      }
+      case 'week': {
+        const weekStartDate = new Date(parsedDate);
+        weekStartDate.setDate(weekStartDate.getDate() - 6 * interval);
+        const { month, year, today } = this.parseJsDate(weekStartDate);
+        return {
+          lt: new Date(year, month, today).toISOString()
+        };
+      }
+      case 'hour': {
+        const previousHour = parsedDate.getHours() - interval;
+        return {
+          lt: new Date(year, month, today, previousHour).toISOString()
+        };
+      }
+      default: {
+        return {
+          $lt: new Date(year, month, today - interval).toISOString()
+        };
+      }
+    }
+  }
+
+  private listConnectionsDateRangeQuery(data: event_types.ListCurrentConnectionsRequest) {
+    const { range } = data;
+    if (!range) {
+      const query = `
+        WITH filtered AS (
+              SELECT *
+              FROM sdk_report_events
+              WHERE disconnect_at IS NULL
+              AND jwt_exp > NOW()
+                        ),
+        unique_users AS (
+              SELECT COUNT(DISTINCT user_id) AS count
+              FROM filtered
+                        ),
+        sdk_versions_array AS (
+              SELECT sdk,
+              COUNT(*) AS total,
+              COUNT(DISTINCT client_id) AS clients,
+              COUNT(DISTINCT user_id) AS users
+              FROM filtered
+              GROUP BY sdk
+                            )
+        SELECT
+          COALESCE(u.count, 0) AS users,
+          JSON_AGG(ROW_TO_JSON(s)) AS sdks
+        FROM unique_users u
+        JOIN sdk_versions_array s ON TRUE;
+    `;
+      return {
+        statement: query
+      };
+    }
+    const endDate = data.range?.end_date ? new Date(data.range.end_date) : new Date();
+    const startDate = new Date(range.start_date);
+    const query = `
+      WITH filtered AS (
+              SELECT *
+              FROM sdk_report_events
+              WHERE disconnect_at IS NULL
+              AND jwt_exp > NOW()
+              AND connect_at > $1
+              AND connect_at <= $2
+      ),
+      unique_users AS (
+              SELECT COUNT(DISTINCT user_id) AS count
+              FROM filtered
+                        ),
+      sdk_versions_array AS (
+              SELECT sdk,
+              COUNT(*) AS total,
+              COUNT(DISTINCT client_id) AS clients,
+              COUNT(DISTINCT user_id) AS users
+              FROM filtered
+              GROUP BY sdk
+                            )
+      SELECT COALESCE(u.count, 0) AS users, JSON_AGG(ROW_TO_JSON(s)) AS sdks
+      FROM unique_users u
+      JOIN sdk_versions_array s ON TRUE;
+    `;
+    const lt = endDate.toISOString();
+    const gt = startDate.toISOString();
+    return { statement: query, params: [{ value: gt }, { value: lt }] };
   }
-  reportSdkDisconnect(data: SdkDisconnectEventData): Promise<void> {
-    throw new Error('Method not implemented.');
+
+  private updateTableFilter() {
+    const { year, month, today } = this.parseJsDate(new Date());
+    const nextDay = today + 1;
+    return {
+      gte: new Date(year, month, today).toISOString(),
+      lt: new Date(year, month, nextDay).toISOString()
+    };
   }
-  listCurrentConnections(data: ListCurrentConnectionsRequest): Promise<ListCurrentConnections> {
-    throw new Error('Method not implemented.');
+
+  async reportSdkConnect(data: SdkConnectBucketData): Promise<void> {
+    const { sdk, connect_at, user_id, user_agent, jwt_exp, client_id } = data;
+    const { gte, lt } = this.updateTableFilter();
+    const query = `
+    INSERT INTO sdk_report_events (user_id, client_id, connect_at, sdk, user_agent, jwt_exp, id)
+    VALUES ($1, $2, $3, $4, $5, $6, $7)
+    ON CONFLICT (user_id, client_id, connect_at)
+    DO UPDATE SET
+      connect_at = $3,
+      sdk = $4,
+      user_agent = $5,
+      jwt_exp = $6,
+      disconnect_at = NULL
+    WHERE sdk_report_events.connect_at >= $8
+      AND sdk_report_events.connect_at < $9;`;
+    try {
+      const result = await this.db.query({
+        statement: query,
+        params: [
+          { type: 'varchar', value: user_id },
+          { type: 'varchar', value: client_id },
+          { type: 'varchar', value: connect_at },
+          { type: 'varchar', value: sdk },
+          { type: 'varchar', value: user_agent },
+          { type: 1184, value: jwt_exp?.toISOString() },
+          { type: 'varchar', value: v4() },
+          { type: 1184, value: gte },
+          { type: 1184, value: lt }
+        ]
+      });
+      console.log(result.rows);
+    } catch (error) {
+      console.log(error);
+    }
   }
-  scrapeSdkData(data: ScrapeSdkDataRequest): Promise<ListCurrentConnections> {
-    throw new Error('Method not implemented.');
+  async reportSdkDisconnect(data: SdkDisconnectEventData): Promise<void> {
+    const { user_id, client_id, disconnect_at } = data;
+    const { gte, lt } = this.updateTableFilter();
+    const query = `
+      UPDATE sdk_report_events
+      SET
+        disconnect_at = $1,
+        jwt_exp = NULL
+      WHERE user_id = $2
+        AND client_id = $3
+        AND connect_at >= $4
+        AND connect_at < $5;`;
+
+    try {
+      const result = await this.db.query({
+        statement: query,
+        params: [
+          { type: 1184, value: disconnect_at },
+          { type: 'varchar', value: user_id },
+          { type: 'varchar', value: client_id },
+          { type: 1184, value: gte },
+          { type: 1184, value: lt }
+        ]
+      });
+      console.log(result.rows);
+    } catch (error) {
+      console.log(error);
+    }
+  }
+  async listCurrentConnections(data: ListCurrentConnectionsRequest): Promise<ListCurrentConnections> {
+    const statement = this.listConnectionsDateRangeQuery(data);
+    const result = await this.db.query(statement);
+    console.log(result.rows);
+    return {
+      users: 0,
+      sdks: []
+    };
+  }
+
+  async scrapeSdkData(data: ScrapeSdkDataRequest): Promise<ListCurrentConnections> {
+    const { timeframe, interval } = data;
+    const { lt, gt } = this.timeFrameQuery(timeframe, interval);
+    const query = `
+      WITH filtered AS (
+            SELECT *
+            FROM sdk_report_events
+            WHERE connect_at > $1
+            AND connect_at <= $2
+                        ),
+      unique_users AS (
+            SELECT COUNT(DISTINCT user_id) AS count
+            FROM filtered
+                        ),
+      sdk_versions_array AS (
+            SELECT sdk,
+            COUNT(*) AS total,
+            COUNT(DISTINCT client_id) AS clients,
+            COUNT(DISTINCT user_id) AS users
+            FROM filtered
+            GROUP BY sdk
+                            )
+      SELECT COALESCE(u.count, 0) AS users, JSON_AGG(ROW_TO_JSON(s)) AS sdks
+      FROM unique_users u
+      JOIN sdk_versions_array s ON TRUE;
+    `;
+    const result = await this.db.query({ statement: query, params: [{ value: gt }, { value: lt }] });
+    console.log(result.rows);
+    return {
+      users: 0,
+      sdks: []
+    };
   }
-  deleteOldSdkData(data: DeleteOldSdkData): Promise<void> {
-    throw new Error('Method not implemented.');
+  async deleteOldSdkData(data: DeleteOldSdkData): Promise<void> {
+    const { timeframe, interval } = data;
+    const { lt } = this.timeFrameDeleteQuery(timeframe, interval);
+    const query = `
+    DELETE FROM sdk_report_events
+    WHERE connect_at < $1
+      AND (
+        disconnect_at IS NOT NULL
+        OR (jwt_exp < NOW() AND disconnect_at IS NULL)
+          );
+`;
+    const params = [{ value: lt }];
+    const result = await this.db.query({ statement: query, params });
+    console.log(result.rows);
   }
 
   async [Symbol.asyncDispose]() {

package/src/storage/PostgresStorageProvider.ts

@@ -35,14 +35,17 @@ export class PostgresStorageProvider implements storage.BucketStorageProvider {
     });
 
     return {
-      // TODO: IMPLEMENT REPORT STORAGE
       reportStorage: reportStorageFactory,
       storage: storageFactory,
-      shutDown: async () => storageFactory.db[Symbol.asyncDispose](),
+      shutDown: async () => {
+        await storageFactory.db[Symbol.asyncDispose]();
+        await reportStorageFactory.db[Symbol.asyncDispose]();
+      },
       tearDown: async () => {
         logger.info(`Tearing down Postgres storage: ${normalizedConfig.database}...`);
         await dropTables(storageFactory.db);
         await storageFactory.db[Symbol.asyncDispose]();
+        await reportStorageFactory.db[Symbol.asyncDispose]();
         return true;
       }
     } satisfies storage.ActiveStorage;