fix: as per other plugins

supertokens · Oct 4, 2024 · c8ce3df · c8ce3df
1 parent 8151588
commit c8ce3df
Show file tree

Hide file tree

Showing 6 changed files with 119 additions and 75 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,11 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [7.2.0] - 2024-10-03
+
+- Compatible with plugin interface version 6.3
+- Adds support for OAuthStorage
+
 ## [7.1.3] - 2024-09-04
 
 - Adds index on `last_active_time` for `user_last_active` table to improve the performance of MAU computation.

diff --git a/build.gradle b/build.gradle
@@ -2,7 +2,7 @@ plugins {
     id 'java-library'
 }
 
-version = "7.1.3"
+version = "7.2.0"
 
 repositories {
     mavenCentral()

diff --git a/pluginInterfaceSupported.json b/pluginInterfaceSupported.json
@@ -1,6 +1,6 @@
 {
   "_comment": "contains a list of plugin interfaces branch names that this core supports",
   "versions": [
-    "6.2"
+    "6.3"
   ]
 }
diff --git a/src/main/java/io/supertokens/storage/mysql/Start.java b/src/main/java/io/supertokens/storage/mysql/Start.java
@@ -58,7 +58,10 @@
 import io.supertokens.pluginInterface.multitenancy.exceptions.TenantOrAppNotFoundException;
 import io.supertokens.pluginInterface.multitenancy.sqlStorage.MultitenancySQLStorage;
 import io.supertokens.pluginInterface.oauth.OAuthLogoutChallenge;
+import io.supertokens.pluginInterface.oauth.OAuthRevokeTargetType;
 import io.supertokens.pluginInterface.oauth.OAuthStorage;
+import io.supertokens.pluginInterface.oauth.exception.DuplicateOAuthLogoutChallengeException;
+import io.supertokens.pluginInterface.oauth.exception.OAuthClientNotFoundException;
 import io.supertokens.pluginInterface.passwordless.PasswordlessCode;
 import io.supertokens.pluginInterface.passwordless.PasswordlessDevice;
 import io.supertokens.pluginInterface.passwordless.exception.*;
@@ -3037,159 +3040,192 @@ public int countUsersThatHaveMoreThanOneLoginMethodOrTOTPEnabledAndActiveSince(A
     }
 
     @Override
-    public boolean doesClientIdExistForApp(AppIdentifier appIdentifier, String clientId)
+    public boolean doesOAuthClientIdExist(AppIdentifier appIdentifier, String clientId)
             throws StorageQueryException {
         try {
-            return OAuthQueries.isClientIdForAppId(this, clientId, appIdentifier);
+            return OAuthQueries.doesOAuthClientIdExist(this, clientId, appIdentifier);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void addOrUpdateClientForApp(AppIdentifier appIdentifier, String clientId, boolean isClientCredentialsOnly)
-            throws StorageQueryException {
+    public void addOrUpdateOauthClient(AppIdentifier appIdentifier, String clientId, boolean isClientCredentialsOnly)
+            throws StorageQueryException, TenantOrAppNotFoundException {
         try {
-            OAuthQueries.insertClientIdForAppId(this, appIdentifier, clientId, isClientCredentialsOnly);
+            OAuthQueries.addOrUpdateOauthClient(this, appIdentifier, clientId, isClientCredentialsOnly);
         } catch (SQLException e) {
+            if (e instanceof SQLIntegrityConstraintViolationException) {
+                MySQLConfig config = Config.getConfig(this);
+                String serverMessage = e.getMessage();
+
+                if (isForeignKeyConstraintError(serverMessage, config.getAppsTable(), "app_id")) {
+                    throw new TenantOrAppNotFoundException(appIdentifier);
+                }
+            }
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public boolean removeAppClientAssociation(AppIdentifier appIdentifier, String clientId)
-            throws StorageQueryException {
+    public boolean deleteOAuthClient(AppIdentifier appIdentifier, String clientId) throws StorageQueryException {
         try {
-            return OAuthQueries.deleteClientIdForAppId(this, clientId, appIdentifier);
+            return OAuthQueries.deleteOAuthClient(this, clientId, appIdentifier);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public List<String> listClientsForApp(AppIdentifier appIdentifier) throws StorageQueryException {
+    public List<String> listOAuthClients(AppIdentifier appIdentifier) throws StorageQueryException {
         try {
-            return OAuthQueries.listClientsForApp(this, appIdentifier);
+            return OAuthQueries.listOAuthClients(this, appIdentifier);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void revoke(AppIdentifier appIdentifier, String targetType, String targetValue, long exp)
-            throws StorageQueryException {
+    public void revokeOAuthTokensBasedOnTargetFields(AppIdentifier appIdentifier, OAuthRevokeTargetType targetType, String targetValue, long exp)
+            throws StorageQueryException, TenantOrAppNotFoundException {
         try {
-            OAuthQueries.revoke(this, appIdentifier, targetType, targetValue, exp);
+            OAuthQueries.revokeOAuthTokensBasedOnTargetFields(this, appIdentifier, targetType, targetValue, exp);
         } catch (SQLException e) {
+            if (e instanceof SQLIntegrityConstraintViolationException) {
+                MySQLConfig config = Config.getConfig(this);
+                String serverMessage = e.getMessage();
+
+                if (isForeignKeyConstraintError(serverMessage, config.getAppsTable(), "app_id")) {
+                    throw new TenantOrAppNotFoundException(appIdentifier);
+                }
+            }
             throw new StorageQueryException(e);
         }
+
     }
 
     @Override
-    public boolean isRevoked(AppIdentifier appIdentifier, String[] targetTypes, String[] targetValues, long issuedAt)
+    public boolean isOAuthTokenRevokedBasedOnTargetFields(AppIdentifier appIdentifier, OAuthRevokeTargetType[] targetTypes, String[] targetValues, long issuedAt)
             throws StorageQueryException {
         try {
-            return OAuthQueries.isRevoked(this, appIdentifier, targetTypes, targetValues, issuedAt);
+            return OAuthQueries.isOAuthTokenRevokedBasedOnTargetFields(this, appIdentifier, targetTypes, targetValues, issuedAt);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void addM2MToken(AppIdentifier appIdentifier, String clientId, long iat, long exp)
-            throws StorageQueryException {
+    public void addOAuthM2MTokenForStats(AppIdentifier appIdentifier, String clientId, long iat, long exp)
+            throws StorageQueryException, OAuthClientNotFoundException {
         try {
-            OAuthQueries.addM2MToken(this, appIdentifier, clientId, iat, exp);
+            OAuthQueries.addOAuthM2MTokenForStats(this, appIdentifier, clientId, iat, exp);
         } catch (SQLException e) {
+            if (e instanceof SQLIntegrityConstraintViolationException) {
+                MySQLConfig config = Config.getConfig(this);
+                String serverMessage = e.getMessage();
+
+                if (isForeignKeyConstraintError(serverMessage, config.getOAuthClientsTable(), "client_id")) {
+                    throw new OAuthClientNotFoundException();
+                }
+            }
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void addLogoutChallenge(AppIdentifier appIdentifier, String challenge, String clientId,
-            String postLogoutRedirectionUri, String sessionHandle, String state, long timeCreated) throws StorageQueryException {
+    public void cleanUpExpiredAndRevokedOAuthTokensList() throws StorageQueryException {
         try {
-            OAuthQueries.addLogoutChallenge(this, appIdentifier, challenge, clientId, postLogoutRedirectionUri, sessionHandle, state, timeCreated);
+            OAuthQueries.cleanUpExpiredAndRevokedOAuthTokensList(this);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public OAuthLogoutChallenge getLogoutChallenge(AppIdentifier appIdentifier, String challenge)
-            throws StorageQueryException {
+    public void addOAuthLogoutChallenge(AppIdentifier appIdentifier, String challenge, String clientId,
+            String postLogoutRedirectionUri, String sessionHandle, String state, long timeCreated)
+            throws StorageQueryException, DuplicateOAuthLogoutChallengeException, OAuthClientNotFoundException {
         try {
-            return OAuthQueries.getLogoutChallenge(this, appIdentifier, challenge);
+            OAuthQueries.addOAuthLogoutChallenge(this, appIdentifier, challenge, clientId, postLogoutRedirectionUri, sessionHandle, state, timeCreated);
         } catch (SQLException e) {
+            if (e instanceof SQLIntegrityConstraintViolationException) {
+                MySQLConfig config = Config.getConfig(this);
+                String serverMessage = e.getMessage();
+                if (isPrimaryKeyError(serverMessage, config.getOAuthLogoutChallengesTable())) {
+                    throw new DuplicateOAuthLogoutChallengeException();
+                }
+                else if (isForeignKeyConstraintError(serverMessage, config.getOAuthClientsTable(), "client_id")) {
+                    throw new OAuthClientNotFoundException();
+                }
+            }
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void deleteLogoutChallenge(AppIdentifier appIdentifier, String challenge) throws StorageQueryException {
+    public OAuthLogoutChallenge getOAuthLogoutChallenge(AppIdentifier appIdentifier, String challenge) throws StorageQueryException {
         try {
-            OAuthQueries.deleteLogoutChallenge(this, appIdentifier, challenge);
+            return OAuthQueries.getOAuthLogoutChallenge(this, appIdentifier, challenge);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void deleteLogoutChallengesBefore(AppIdentifier appIdentifier, long time) throws StorageQueryException {
+    public void deleteOAuthLogoutChallenge(AppIdentifier appIdentifier, String challenge) throws StorageQueryException {
         try {
-            OAuthQueries.deleteLogoutChallengesBefore(this, appIdentifier, time);
+            OAuthQueries.deleteOAuthLogoutChallenge(this, appIdentifier, challenge);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public void cleanUpExpiredAndRevokedTokens(AppIdentifier appIdentifier) throws StorageQueryException {
+    public void deleteOAuthLogoutChallengesBefore(long time) throws StorageQueryException {
         try {
-            OAuthQueries.cleanUpExpiredAndRevokedTokens(this, appIdentifier);
+            OAuthQueries.deleteOAuthLogoutChallengesBefore(this, time);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public int countTotalNumberOfM2MTokensAlive(AppIdentifier appIdentifier) throws StorageQueryException {
+    public int countTotalNumberOfOAuthClients(AppIdentifier appIdentifier) throws StorageQueryException {
         try {
-            return OAuthQueries.countTotalNumberOfM2MTokensAlive(this, appIdentifier);
+            return OAuthQueries.countTotalNumberOfClients(this, appIdentifier, false);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public int countTotalNumberOfM2MTokensCreatedSince(AppIdentifier appIdentifier, long since)
+    public int countTotalNumberOfClientCredentialsOnlyOAuthClients(AppIdentifier appIdentifier)
             throws StorageQueryException {
         try {
-            return OAuthQueries.countTotalNumberOfM2MTokensCreatedSince(this, appIdentifier, since);
+            return OAuthQueries.countTotalNumberOfClients(this, appIdentifier, true);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public int countTotalNumberOfClientCredentialsOnlyClientsForApp(AppIdentifier appIdentifier)
+    public int countTotalNumberOfOAuthM2MTokensCreatedSince(AppIdentifier appIdentifier, long since)
             throws StorageQueryException {
         try {
-            return OAuthQueries.countTotalNumberOfClientsForApp(this, appIdentifier, true);
+            return OAuthQueries.countTotalNumberOfOAuthM2MTokensCreatedSince(this, appIdentifier, since);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
         }
     }
 
     @Override
-    public int countTotalNumberOfClientsForApp(AppIdentifier appIdentifier) throws StorageQueryException {
+    public int countTotalNumberOfOAuthM2MTokensAlive(AppIdentifier appIdentifier) throws StorageQueryException {
         try {
-            return OAuthQueries.countTotalNumberOfClientsForApp(this, appIdentifier, false);
+            return OAuthQueries.countTotalNumberOfOAuthM2MTokensAlive(this, appIdentifier);
         } catch (SQLException e) {
             throw new StorageQueryException(e);
-        }
     }
-
+    }
 
     public static boolean isEnabledForDeadlockTesting() {
         return enableForDeadlockTesting;

diff --git a/src/main/java/io/supertokens/storage/mysql/queries/GeneralQueries.java b/src/main/java/io/supertokens/storage/mysql/queries/GeneralQueries.java
@@ -428,6 +428,7 @@ public static void createTablesIfNotExists(Start start, Connection con) throws S
 
             // index
             update(con, OAuthQueries.getQueryToCreateOAuthRevokeTimestampIndex(start), NO_OP_SETTER);
+            update(con, OAuthQueries.getQueryToCreateOAuthRevokeExpIndex(start), NO_OP_SETTER);
         }
 
         if (!doesTableExists(start, con, Config.getConfig(start).getOAuthM2MTokensTable())) {