feat(user_metadata): adds support for usermetadata (#33)

* feat(user_metadata): adds support for usermetadata

* fix: removed old plugin interface version from the supported list

* test(usermetadata): test if concurrently creating a new metadata object deadlocks

* Revert "test(usermetadata): test if concurrently creating a new metadata object deadlocks"

This reverts commit e04fac5.

* fix(user_metadata): add NOT NULL to user_metadata column

Co-authored-by: Mihaly Lengyel <mihaly.lengyel@tresorit.com>
Co-authored-by: Rishabh Poddar <rishabh.poddar@gmail.com>

Author: 3 people

CHANGELOG.md

@@ -8,6 +8,10 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 - Fixes https://github.com/supertokens/supertokens-postgresql-plugin/issues/34
 
+## [1.15.0] - 2022-03-04
+
+- Adds support for the new usermetadata recipe
+
 ## [1.14.0] - 2022-02-23
 
 - Adds an index on device_id_hash to the codes table.

build.gradle

@@ -2,7 +2,7 @@ plugins {
     id 'java-library'
 }
 
-version = "1.14.0"
+version = "1.15.0"
 
 repositories {
     mavenCentral()

pluginInterfaceSupported.json

@@ -1,6 +1,6 @@
 {
   "_comment": "contains a list of plugin interfaces branch names that this core supports",
   "versions": [
-    "2.12"
+    "2.13"
   ]
 }

src/main/java/io/supertokens/storage/postgresql/Start.java

@@ -48,10 +48,14 @@
 import io.supertokens.pluginInterface.sqlStorage.TransactionConnection;
 import io.supertokens.pluginInterface.thirdparty.exception.DuplicateThirdPartyUserException;
 import io.supertokens.pluginInterface.thirdparty.sqlStorage.ThirdPartySQLStorage;
+import io.supertokens.pluginInterface.usermetadata.UserMetadataStorage;
+import io.supertokens.pluginInterface.usermetadata.sqlStorage.UserMetadataSQLStorage;
 import io.supertokens.storage.postgresql.config.Config;
 import io.supertokens.storage.postgresql.config.PostgreSQLConfig;
 import io.supertokens.storage.postgresql.output.Logging;
 import io.supertokens.storage.postgresql.queries.*;
+import netscape.javascript.JSObject;
+
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -66,7 +70,7 @@
 import java.util.List;
 
 public class Start implements SessionSQLStorage, EmailPasswordSQLStorage, EmailVerificationSQLStorage,
-        ThirdPartySQLStorage, JWTRecipeSQLStorage, PasswordlessSQLStorage {
+        ThirdPartySQLStorage, JWTRecipeSQLStorage, PasswordlessSQLStorage, UserMetadataSQLStorage {
 
     private static final Object appenderLock = new Object();
     public static boolean silent = false;
@@ -1407,4 +1411,44 @@ public io.supertokens.pluginInterface.passwordless.UserInfo getUserByPhoneNumber
             throw new StorageQueryException(e);
         }
     }
+
+    @Override
+    public JsonObject getUserMetadata(String userId) throws StorageQueryException {
+        try {
+            return UserMetadataQueries.getUserMetadata(this, userId);
+        } catch (SQLException e) {
+            throw new StorageQueryException(e);
+        }
+    }
+
+    @Override
+    public JsonObject getUserMetadata_Transaction(TransactionConnection con, String userId)
+            throws StorageQueryException {
+        Connection sqlCon = (Connection) con.getConnection();
+        try {
+            return UserMetadataQueries.getUserMetadata_Transaction(this, sqlCon, userId);
+        } catch (SQLException e) {
+            throw new StorageQueryException(e);
+        }
+    }
+
+    @Override
+    public int setUserMetadata_Transaction(TransactionConnection con, String userId, JsonObject metadata)
+            throws StorageQueryException {
+        Connection sqlCon = (Connection) con.getConnection();
+        try {
+            return UserMetadataQueries.setUserMetadata_Transaction(this, sqlCon, userId, metadata);
+        } catch (SQLException e) {
+            throw new StorageQueryException(e);
+        }
+    }
+
+    @Override
+    public int deleteUserMetadata(String userId) throws StorageQueryException {
+        try {
+            return UserMetadataQueries.deleteUserMetadata(this, userId);
+        } catch (SQLException e) {
+            throw new StorageQueryException(e);
+        }
+    }
 }

src/main/java/io/supertokens/storage/postgresql/config/PostgreSQLConfig.java

@@ -277,6 +277,10 @@ public String getJWTSigningKeysTable() {
         return addSchemaAndPrefixToTableName("jwt_signing_keys");
     }
 
+    public String getUserMetadataTable() {
+        return addSchemaAndPrefixToTableName("user_metadata");
+    }
+
     private String addSchemaAndPrefixToTableName(String tableName) {
         String name = tableName;
         if (!postgresql_table_names_prefix.trim().equals("")) {

src/main/java/io/supertokens/storage/postgresql/queries/GeneralQueries.java

@@ -57,6 +57,7 @@
 import static io.supertokens.storage.postgresql.queries.PasswordlessQueries.getQueryToCreateDevicesTable;
 import static io.supertokens.storage.postgresql.queries.SessionQueries.getQueryToCreateAccessTokenSigningKeysTable;
 import static io.supertokens.storage.postgresql.queries.SessionQueries.getQueryToCreateSessionInfoTable;
+import static io.supertokens.storage.postgresql.queries.UserMetadataQueries.getQueryToCreateUserMetadataTable;
 
 public class GeneralQueries {
 
@@ -188,6 +189,11 @@ public static void createTablesIfNotExists(Start start) throws SQLException, Sto
                 // index if not exists"
                 // We missed creating this earlier for the codes table, so it may be missing even if the table exists
                 update(start, getQueryToCreateCodeDeviceIdHashIndex(start), NO_OP_SETTER);
+
+                if (!doesTableExists(start, Config.getConfig(start).getUserMetadataTable())) {
+                    getInstance(start).addState(CREATING_NEW_TABLE, null);
+                    update(start, getQueryToCreateUserMetadataTable(start), NO_OP_SETTER);
+                }
             } catch (Exception e) {
                 if (e.getMessage().contains("schema") && e.getMessage().contains("does not exist")
                         && numberOfRetries < 1) {
@@ -231,7 +237,7 @@ public static void deleteAllTables(Start start) throws SQLException, StorageQuer
                     + "," + getConfig(start).getJWTSigningKeysTable() + ","
                     + getConfig(start).getPasswordlessCodesTable() + ","
                     + getConfig(start).getPasswordlessDevicesTable() + ","
-                    + getConfig(start).getPasswordlessUsersTable();
+                    + getConfig(start).getPasswordlessUsersTable() + "," + getConfig(start).getUserMetadataTable();
             update(start, DROP_QUERY, NO_OP_SETTER);
         }
     }

src/main/java/io/supertokens/storage/postgresql/queries/UserMetadataQueries.java

@@ -0,0 +1,90 @@
+/*
+ *    Copyright (c) 2020, VRAI Labs and/or its affiliates. All rights reserved.
+ *
+ *    This software is licensed under the Apache License, Version 2.0 (the
+ *    "License") as published by the Apache Software Foundation.
+ *
+ *    You may not use this file except in compliance with the License. You may
+ *    obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *    License for the specific language governing permissions and limitations
+ *    under the License.
+ */
+
+package io.supertokens.storage.postgresql.queries;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import io.supertokens.pluginInterface.exceptions.StorageQueryException;
+import io.supertokens.storage.postgresql.Start;
+import io.supertokens.storage.postgresql.config.Config;
+import io.supertokens.storage.postgresql.utils.Utils;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import static io.supertokens.storage.postgresql.QueryExecutorTemplate.execute;
+import static io.supertokens.storage.postgresql.QueryExecutorTemplate.update;
+import static io.supertokens.storage.postgresql.config.Config.getConfig;
+
+public class UserMetadataQueries {
+
+    public static String getQueryToCreateUserMetadataTable(Start start) {
+        String schema = Config.getConfig(start).getTableSchema();
+        String tableName = Config.getConfig(start).getUserMetadataTable();
+        // @formatter:off
+        return "CREATE TABLE IF NOT EXISTS " + tableName + " ("
+                + "user_id VARCHAR(128) NOT NULL,"
+                + "user_metadata TEXT NOT NULL,"
+                + "CONSTRAINT " + Utils.getConstraintName(schema, tableName, null, "pkey") + " PRIMARY KEY(user_id)" + " );";
+        // @formatter:on
+
+    }
+
+    public static int deleteUserMetadata(Start start, String userId) throws SQLException, StorageQueryException {
+        String QUERY = "DELETE FROM " + getConfig(start).getUserMetadataTable() + " WHERE user_id = ?";
+
+        return update(start, QUERY.toString(), pst -> pst.setString(1, userId));
+    }
+
+    public static int setUserMetadata_Transaction(Start start, Connection con, String userId, JsonObject metadata)
+            throws SQLException, StorageQueryException {
+
+        String QUERY = "INSERT INTO " + getConfig(start).getUserMetadataTable()
+                + "(user_id, user_metadata) VALUES(?, ?) "
+                + "ON CONFLICT(user_id) DO UPDATE SET user_metadata=excluded.user_metadata;";
+
+        return update(con, QUERY, pst -> {
+            pst.setString(1, userId);
+            pst.setString(2, metadata.toString());
+        });
+    }
+
+    public static JsonObject getUserMetadata_Transaction(Start start, Connection con, String userId)
+            throws SQLException, StorageQueryException {
+        String QUERY = "SELECT user_metadata FROM " + getConfig(start).getUserMetadataTable()
+                + " WHERE user_id = ? FOR UPDATE";
+        return execute(con, QUERY, pst -> pst.setString(1, userId), result -> {
+            if (result.next()) {
+                JsonParser jp = new JsonParser();
+                return jp.parse(result.getString("user_metadata")).getAsJsonObject();
+            }
+            return null;
+        });
+    }
+
+    public static JsonObject getUserMetadata(Start start, String userId) throws SQLException, StorageQueryException {
+        String QUERY = "SELECT user_metadata FROM " + getConfig(start).getUserMetadataTable() + " WHERE user_id = ?";
+        return execute(start, QUERY, pst -> pst.setString(1, userId), result -> {
+            if (result.next()) {
+                JsonParser jp = new JsonParser();
+                return jp.parse(result.getString("user_metadata")).getAsJsonObject();
+            }
+            return null;
+        });
+    }
+}