@makefully/adaptfully 3.0.2 → 3.1.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project are documented in this file.
 
+## 3.1.0 — 2026-06-18
+
+### Added
+
+- Built-in storage plugins: `localStorage` (sync) and `indexedDB` (async).
+- Register with `"storage": "localStorage"` or `"storage": "indexedDB"` in `config.platforms.<platform>.registrations`.
+
+### Changed
+
+- Auth helpers use registered `storage` only (no implicit fallbacks).
+
+## 3.0.3 — 2026-06-18
+
+### Added
+
+- `platform.autoLogin()` and `platform.supportsAutoLogin()` for session restore without UI.
+- Google auth reads `config.autoLoginStorageKey` (default: `lastLoggedIn`) when deciding whether to attempt silent OAuth.
+
+### Changed
+
+- Auth plugins expose `autoLogin()` only (removed `silentLogin()`).
+
+### Fixed
+
+- Google auth reads OAuth config and stored tokens lazily so bridge-registered `config`/`storage` are applied before auto-login runs.
+- Prebuild injects deploy bridge scripts after `core.js` and before auth plugin runtime scripts.
+- Auth storage helper falls back to `localStorage` when `storage` is not registered via Adaptfully.
+
 ## 3.0.2 — 2026-06-18
 
 ### Fixed

package/README.md

@@ -45,6 +45,21 @@ const platform = adaptfully.get('auth');
 platform.login(function (result) { /* ... */ });
 ```
 
+### Storage plugins
+
+| Plugin key | Registration | Runtime |
+|------------|--------------|---------|
+| `localStorage` | `adaptfully.register('storage', adaptfully.storage.LocalStorage())` | Sync key/value storage in the browser |
+| `indexedDB` | `adaptfully.register('storage', adaptfully.storage.IndexedDB())` | Async key/value storage for larger payloads |
+
+In-game:
+
+```javascript
+const storage = adaptfully.get('storage');
+storage.set('playerName', 'Ada');
+storage.getObject('currentGame');
+```
+
 ### Auth plugins
 
 | Plugin key | Registration | Runtime |
@@ -61,18 +76,19 @@ Use plugin keys in `config.platforms.<platform>.registrations`. Custom deploy sc
     "platforms": {
       "steam": {
         "registrations": {
-          "auth": "steam-auth",
-          "storage": "/javascript/custom-storage-solution.js"
+          "storage": "localStorage",
+          "auth": "steam-auth"
         }
       },
       "web": {
         "registrations": {
-          "auth": "google-auth",
-          "storage": "javascript/adaptfully-bridge.js"
+          "storage": "localStorage",
+          "auth": "google-auth"
         }
       },
       "dev": {
         "registrations": {
+          "storage": "localStorage",
           "auth": "dev-auth"
         }
       }
@@ -107,6 +123,8 @@ import {
 - **`prebuildPlatform(deployFolder, platformKey, pkg)`** — copy `deploy/` to `output/<platform>-prebuild/` and inject registrations into `config.htmlInjections` (default: `index.html`).
 - **`resolveRegistrationAssets(registrations)`** — resolve runtime script paths, inline registration JS, and external script tags for a registration map (useful for Vite dev servers).
 - **`runAdaptfullyStage('prebuild' | 'build' | 'deploy', platformKey, options)`** — run a pipeline stage programmatically.
+- **`platform.autoLogin(callback)`** — restore a prior session without UI when the auth plugin supports it (Google uses `lastLoggedIn` in storage and a cached OAuth token).
+- **`platform.supportsAutoLogin()`** — whether the active auth plugin can attempt automatic sign-in.
 
 ---
 

package/lib/node/registrations.js

@@ -25,6 +25,14 @@ export const STANDARD_PLUGINS = {
         scripts: ['core.js', 'platform.js', 'auth/_helpers.js', 'auth/dev-auth.js'],
         registration: (key) => `adaptfully.register('${key}', adaptfully.auth.Dev);`,
     },
+    localStorage: {
+        scripts: ['core.js', 'storage/_helpers.js', 'storage/local-storage.js'],
+        registration: (key) => `adaptfully.register('${key}', adaptfully.storage.LocalStorage());`,
+    },
+    indexedDB: {
+        scripts: ['core.js', 'storage/_helpers.js', 'storage/indexed-db.js'],
+        registration: (key) => `adaptfully.register('${key}', adaptfully.storage.IndexedDB());`,
+    },
 };
 
 /** Default Wrapfully builder → config.platforms key */
@@ -201,7 +209,11 @@ export function buildAdaptfullyInjection(registrations, options = {}) {
         block += `${extScript}\n`;
     }
 
-    for (const script of parts.runtimeScripts) {
+    const coreScript = 'core.js';
+    const bootstrapScripts = parts.runtimeScripts.filter((script) => script === coreScript);
+    const pluginScripts = parts.runtimeScripts.filter((script) => script !== coreScript);
+
+    for (const script of bootstrapScripts) {
         block += `<script>\n${readRuntimeScript(script)}\n</script>\n`;
     }
 
@@ -209,6 +221,10 @@ export function buildAdaptfullyInjection(registrations, options = {}) {
         block += `<script src="${src}"></script>\n`;
     }
 
+    for (const script of pluginScripts) {
+        block += `<script>\n${readRuntimeScript(script)}\n</script>\n`;
+    }
+
     if (parts.inlineRegistrations.length > 0) {
         block += `<script>\n${parts.inlineRegistrations.join('\n')}\n</script>\n`;
     }

package/lib/runtime/auth/_helpers.js

@@ -9,7 +9,8 @@
  * @property {string} name
  * @property {(done: ReadyCallback) => void} whenReady
  * @property {(callback: AuthCallback) => void} login
- * @property {(callback: AuthCallback) => void} silentLogin
+ * @property {(callback: AuthCallback) => void} autoLogin
+ * @property {() => boolean} [supportsAutoLogin]
  * @property {(callback: () => void) => void} logout
  * @property {() => AuthUser | null} getUser
  * @property {() => boolean} isAuthenticated

package/lib/runtime/auth/dev-auth.js

@@ -50,10 +50,14 @@
                 });
         }
 
-        silentLogin(callback) {
+        autoLogin(callback) {
             callback({ authenticated: this.authenticated, user: this.getUser() });
         }
 
+        supportsAutoLogin() {
+            return true;
+        }
+
         logout(callback) {
             const storage = getStorage();
             this.authenticated = false;

package/lib/runtime/auth/google-auth.js

@@ -6,24 +6,42 @@
     const DEFAULT_CLIENT_ID = '225754014403.apps.googleusercontent.com';
     const DEFAULT_SCOPES = 'openid email profile';
     const DEFAULT_TOKEN_KEY = 'adaptfully_google_token';
+    const DEFAULT_AUTO_LOGIN_KEY = 'lastLoggedIn';
 
     class GoogleAuthPlugin {
         constructor() {
             this.name = 'google';
             this.tokenClient = null;
-            this.tokenKey = configValue('googleTokenKey', DEFAULT_TOKEN_KEY);
-            this.clientId = configValue('googleClientId', DEFAULT_CLIENT_ID);
-            this.scopes = configValue('googleScopes', DEFAULT_SCOPES);
-            this.accessToken = sessionStorage.getItem(this.tokenKey) || '';
+            this.accessToken = '';
             this.user = null;
             this.authenticated = false;
         }
 
+        supportsAutoLogin() {
+            return true;
+        }
+
+        #tokenKey() {
+            return configValue('googleTokenKey', DEFAULT_TOKEN_KEY);
+        }
+
+        #clientId() {
+            return configValue('googleClientId', DEFAULT_CLIENT_ID);
+        }
+
+        #scopes() {
+            return configValue('googleScopes', DEFAULT_SCOPES);
+        }
+
+        #autoLoginStorageKey() {
+            return configValue('autoLoginStorageKey', DEFAULT_AUTO_LOGIN_KEY);
+        }
+
         whenReady(done) {
             const setup = () => {
                 this.tokenClient = google.accounts.oauth2.initTokenClient({
-                    client_id: this.clientId,
-                    scope: this.scopes,
+                    client_id: this.#clientId(),
+                    scope: this.#scopes(),
                     callback: () => {},
                 });
                 done();
@@ -60,12 +78,19 @@
             this.accessToken = '';
             this.user = null;
             this.authenticated = false;
-            sessionStorage.removeItem(this.tokenKey);
+            sessionStorage.removeItem(this.#tokenKey());
+        }
+
+        #loadStoredToken() {
+            if (!this.accessToken) {
+                this.accessToken = sessionStorage.getItem(this.#tokenKey()) || '';
+            }
         }
 
         #hasPersistedLogin() {
             const storage = getStorage();
-            return !!(storage?.get('lastLoggedIn'));
+            const key = this.#autoLoginStorageKey();
+            return !!(storage?.get(key));
         }
 
         #fetchUserInfo(token, callback) {
@@ -80,7 +105,7 @@
                 })
                 .then((data) => {
                     this.accessToken = token;
-                    sessionStorage.setItem(this.tokenKey, token);
+                    sessionStorage.setItem(this.#tokenKey(), token);
                     this.#applyUserInfo(data);
                     callback();
                 })
@@ -103,6 +128,8 @@
         }
 
         #restoreSession(callback) {
+            this.#loadStoredToken();
+
             const trySilentGoogleLogin = () => {
                 if (this.#hasPersistedLogin()) {
                     this.#requestAccessToken('none', callback);
@@ -135,7 +162,7 @@
             });
         }
 
-        silentLogin(callback) {
+        autoLogin(callback) {
             if (this.authenticated && this.user?.id) {
                 callback({ authenticated: true, user: this.getUser() });
                 return;
@@ -149,7 +176,7 @@
             const storage = getStorage();
             const finish = () => {
                 this.#clearSession();
-                storage?.remove('lastLoggedIn');
+                storage?.remove(this.#autoLoginStorageKey());
                 callback();
             };
 

package/lib/runtime/auth/steam-auth.js

@@ -22,10 +22,14 @@
             callback({ authenticated: this.authenticated, user: this.getUser() });
         }
 
-        silentLogin(callback) {
+        autoLogin(callback) {
             callback({ authenticated: this.authenticated, user: this.getUser() });
         }
 
+        supportsAutoLogin() {
+            return false;
+        }
+
         logout(callback) {
             const storage = getStorage();
             this.user = null;

package/lib/runtime/platform.js

@@ -53,13 +53,17 @@
             });
         }
 
-        silentLogin(callback) {
+        autoLogin(callback) {
             this.whenReady(() => {
                 if (!this.online) {
                     callback({ authenticated: false });
                     return;
                 }
-                this.auth.silentLogin((result) => {
+                if (typeof this.auth.autoLogin !== 'function') {
+                    callback({ authenticated: false });
+                    return;
+                }
+                this.auth.autoLogin((result) => {
                     callback(result || {
                         authenticated: this.auth.isAuthenticated(),
                         user: this.auth.getUser(),
@@ -68,6 +72,12 @@
             });
         }
 
+        supportsAutoLogin() {
+            return typeof this.auth.supportsAutoLogin === 'function'
+                ? this.auth.supportsAutoLogin()
+                : typeof this.auth.autoLogin === 'function';
+        }
+
         logout(callback) {
             this.whenReady(() => {
                 this.auth.logout(() => {

package/lib/runtime/storage/_helpers.js

@@ -0,0 +1,5 @@
+/* global window */
+
+(function registerStorageHelpers(ns) {
+    ns.storage = ns.storage || {};
+}(window.adaptfully));

package/lib/runtime/storage/indexed-db.js

@@ -0,0 +1,87 @@
+/* global indexedDB, window */
+
+(function registerIndexedDBStorage(ns) {
+    function configValue(key, fallback) {
+        if (!ns.has('config')) {
+            return fallback;
+        }
+        const config = ns.get('config');
+        return config?.[key] != null ? config[key] : fallback;
+    }
+
+    ns.storage.IndexedDB = function indexedDBFactory() {
+        const dbName = configValue('indexedDBName', 'adaptfully');
+        const storeName = configValue('indexedDBStoreName', 'storage');
+        /** @type {Promise<IDBDatabase> | null} */
+        let dbPromise = null;
+
+        function openDb() {
+            if (!dbPromise) {
+                dbPromise = new Promise((resolve, reject) => {
+                    const request = indexedDB.open(dbName, 1);
+                    request.onupgradeneeded = () => {
+                        request.result.createObjectStore(storeName);
+                    };
+                    request.onsuccess = () => resolve(request.result);
+                    request.onerror = () => reject(request.error);
+                });
+            }
+            return dbPromise;
+        }
+
+        function withStore(mode, fn) {
+            return openDb().then((db) => new Promise((resolve, reject) => {
+                const tx = db.transaction(storeName, mode);
+                const store = tx.objectStore(storeName);
+                const request = fn(store);
+                request.onsuccess = () => resolve(request.result);
+                request.onerror = () => reject(request.error);
+            }));
+        }
+
+        return {
+            name: 'indexedDB',
+            async get(field) {
+                try {
+                    const value = await withStore('readonly', (store) => store.get(field));
+                    return value === undefined ? false : value;
+                } catch {
+                    return false;
+                }
+            },
+            async set(field, value) {
+                await this.remove(field);
+                try {
+                    await withStore('readwrite', (store) => store.put(value, field));
+                } catch {
+                    // ignore
+                }
+            },
+            async remove(field) {
+                try {
+                    await withStore('readwrite', (store) => store.delete(field));
+                } catch {
+                    // ignore
+                }
+            },
+            async getObject(field) {
+                const raw = await this.get(field);
+                if (!raw) {
+                    return false;
+                }
+                try {
+                    return JSON.parse(raw);
+                } catch {
+                    return false;
+                }
+            },
+            async setObject(field, obj) {
+                try {
+                    await this.set(field, JSON.stringify(obj));
+                } catch {
+                    // ignore
+                }
+            },
+        };
+    };
+}(window.adaptfully));

package/lib/runtime/storage/local-storage.js

@@ -0,0 +1,50 @@
+/* global localStorage, window */
+
+(function registerLocalStorage(ns) {
+    ns.storage.LocalStorage = function localStorageFactory() {
+        return {
+            name: 'localStorage',
+            get(field) {
+                try {
+                    const value = localStorage.getItem(field);
+                    return value === null ? false : value;
+                } catch {
+                    return false;
+                }
+            },
+            set(field, value) {
+                this.remove(field);
+                try {
+                    localStorage.setItem(field, value);
+                } catch {
+                    // quota or private browsing
+                }
+            },
+            remove(field) {
+                try {
+                    localStorage.removeItem(field);
+                } catch {
+                    // ignore
+                }
+            },
+            getObject(field) {
+                const raw = this.get(field);
+                if (!raw) {
+                    return false;
+                }
+                try {
+                    return JSON.parse(raw);
+                } catch {
+                    return false;
+                }
+            },
+            setObject(field, obj) {
+                try {
+                    this.set(field, JSON.stringify(obj));
+                } catch {
+                    // ignore
+                }
+            },
+        };
+    };
+}(window.adaptfully));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@makefully/adaptfully",
-    "version": "3.0.2",
+    "version": "3.1.0",
     "description": "Platform abstraction and Wrapfully deploy client for Makefully games",
     "type": "module",
     "main": "./lib/node/index.js",