feat: introduce notification selection via driver

Author: KernelDeimos

packages/backend/src/CoreModule.js

@@ -17,6 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 const { AdvancedBase } = require("@heyputer/puter-js-common");
+const { NotificationES } = require("./om/entitystorage/NotificationES");
 const { Context } = require('./util/context');
 
 
@@ -89,6 +90,8 @@ const install = async ({ services, app, useapi }) => {
     const SubdomainES = require('./om/entitystorage/SubdomainES');
     const { MaxLimitES } = require('./om/entitystorage/MaxLimitES');
     const { AppLimitedES } = require('./om/entitystorage/AppLimitedES');
+    const { ReadOnlyES } = require('./om/entitystorage/ReadOnlyES');
+    const { OwnerLimitedES } = require('./om/entitystorage/OwnerLimitedES');
     const { ESBuilder } = require('./om/entitystorage/ESBuilder');
     const { Eq, Or } = require('./om/query/query');
     const { TrackSpendingService } = require('./services/TrackSpendingService');
@@ -165,6 +168,17 @@ const install = async ({ services, app, useapi }) => {
             MaxLimitES, { max: 5000 },
         ]),
     });
+    services.registerService('es:notification', EntityStoreService, {
+        entity: 'notification',
+        upstream: ESBuilder.create([
+            SQLES, { table: 'notification', debug: true },
+            NotificationES,
+            OwnerLimitedES,
+            ReadOnlyES,
+            SetOwnerES,
+            MaxLimitES, { max: 50 },
+        ]),
+    })
     services.registerService('rate-limit', RateLimitService);
     services.registerService('monthly-usage', MonthlyUsageService);
     services.registerService('auth', AuthService);

packages/backend/src/om/entitystorage/NotificationES.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2024 Puter Technologies Inc.
+ *
+ * This file is part of Puter.
+ *
+ * Puter is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+const { Eq } = require("../query/query");
+const { BaseES } = require("./BaseES");
+
+class NotificationES extends BaseES {
+    static METHODS = {
+        async create_predicate (id) {
+            if ( id === 'unread' ) {
+                return new Eq({
+                    key: 'read',
+                    value: 0,
+                });
+            }
+            if ( id === 'read' ) {
+                return new Eq({
+                    key: 'read',
+                    value: 1,
+                });
+            }
+        },
+        async read_transform (entity) {
+            await entity.set('value', JSON.parse(await entity.get('value') ?? '{}'));
+        }
+    }
+}
+
+module.exports = { NotificationES };

packages/backend/src/om/entitystorage/OwnerLimitedES.js

@@ -0,0 +1,52 @@
+const { AppUnderUserActorType, UserActorType } = require("../../services/auth/Actor");
+const context = require("../../util/context");
+const { Context } = require("../../util/context");
+const { Eq, Or } = require("../query/query");
+const { BaseES } = require("./BaseES");
+const { Entity } = require("./Entity");
+
+class OwnerLimitedES extends BaseES {
+    // Limit selection to entities owned by the app of the current actor.
+    async select (options) {
+        const actor = Context.get('actor');
+
+        if ( ! (actor.type instanceof UserActorType) ) {
+            return [];
+        }
+
+        let condition = new Eq({
+            key: 'owner',
+            value: actor.type.user.id,
+        });
+
+        options.predicate = options.predicate?.and
+            ? options.predicate.and(condition)
+            : condition;
+
+        return await this.upstream.select(options);
+    }
+
+    // Limit read to entities owned by the app of the current actor.
+    async read (uid) {
+        const actor = Context.get('actor');
+        if ( ! (actor.type instanceof UserActorType) ) {
+            return null;
+        }
+
+        const entity = await this.upstream.read(uid);
+        if ( ! entity ) return null;
+        
+        const entity_owner = await entity.get('owner');
+        let owner_id = entity_owner?.id;
+        if ( entity_owner.id !== actor.type.user.id ) {
+            return null;
+        }
+
+        return entity;
+    }
+}
+
+module.exports = {
+    OwnerLimitedES,
+};
+

packages/backend/src/om/entitystorage/ReadOnlyES.js

@@ -0,0 +1,13 @@
+const APIError = require("../../api/APIError");
+const { BaseES } = require("./BaseES");
+
+class ReadOnlyES extends BaseES {
+    async upsert () {
+        throw APIError.create('forbidden');
+    }
+    async delete () {
+        throw APIError.create('forbidden');
+    }
+}
+
+module.exports = ReadOnlyES;

packages/backend/src/om/mappings/__all__.js

@@ -19,4 +19,5 @@
 module.exports = {
     app: require('./app'),
     subdomain: require('./subdomain'),
+    notification: require('./notification'),
 };

packages/backend/src/om/mappings/notification.js

@@ -0,0 +1,21 @@
+module.exports = {
+    sql: {
+        table_name: 'notification'
+    },
+    primary_identifier: 'uid',
+    properties: {
+        uid: { type: 'uuid' },
+        value: { type: 'json' },
+        read: { type: 'flag' },
+        owner: {
+            type: 'reference',
+            to: 'user',
+            permissions: ['read'],
+            permissible_subproperties: ['username', 'uuid'],
+            sql: {
+                use_id: true,
+                column_name: 'user_id',
+            }
+        }
+    }
+};

packages/backend/src/services/SelfhostedService.js

@@ -15,6 +15,7 @@ class SelfhostedService extends BaseService {
         svc_driver.register_driver('puter-kvstore', new DBKVStore());
         svc_driver.register_driver('puter-apps', new EntityStoreImplementation({ service: 'es:app' }));
         svc_driver.register_driver('puter-subdomains', new EntityStoreImplementation({ service: 'es:subdomain' }));
+        svc_driver.register_driver('puter-notifications', new EntityStoreImplementation({ service: 'es:notification' }));
     }
 }
 

packages/backend/src/services/drivers/interfaces.js

@@ -270,5 +270,9 @@ module.exports = {
     'puter-subdomains': {
         ...ENTITY_STORAGE_INTERFACE,
         description: 'Manage subdomains on Puter.',
-    }
+    },
+    'puter-notifications': {
+        ...ENTITY_STORAGE_INTERFACE,
+        description: 'Read notifications on Puter.',
+    },
 };