@mpgd/adapter-devvit 0.13.4 → 0.13.6

package/dist/notifications-client.js

@@ -1,6 +1,6 @@
-import { assertBridgeNotificationsV2Result, } from '@mpgd/bridge/notifications';
+import { assertBridgeNotificationsV2Result, readBridgeNotificationsHostCode, } from '@mpgd/bridge/notifications';
 import { isNotificationErrorCode, isValidNotificationTimeZone, NotificationError, notificationsProtocol, toNotificationSubscriptionAdapter, } from '@mpgd/platform/notifications';
-import { devvitHostCodeCharacters, devvitNotificationProviderId, } from './notifications-contract.js';
+import { devvitNotificationProviderId } from './notifications-contract.js';
 /**
  * The Devvit profile's provider: reads, the opt-in request, the opt-out
  * (`revokePermission`, because the game renders the consent), and the
@@ -108,7 +108,6 @@ function defaultLocale() {
     const navigatorLike = globalThis.navigator;
     return typeof navigatorLike?.language === 'string' ? navigatorLike.language : undefined;
 }
-const hostCodePattern = new RegExp(`\\(host code (${devvitHostCodeCharacters})\\)$`, 'u');
 function toNotificationError(error) {
     if (error instanceof NotificationError) {
         return error;
@@ -119,7 +118,7 @@ function toNotificationError(error) {
     const message = typeof failure.message === 'string' ? failure.message : undefined;
     const explicit = typeof failure.retryable === 'boolean' ? { retryable: failure.retryable } : {};
     if (isNotificationErrorCode(failure.code)) {
-        const hostCode = message === undefined ? undefined : hostCodePattern.exec(message)?.[1];
+        const hostCode = message === undefined ? undefined : readBridgeNotificationsHostCode(message);
         return new NotificationError(failure.code, {
             ...(message === undefined ? {} : { message }),
             ...explicit,

package/dist/notifications-contract.d.ts

@@ -46,7 +46,9 @@ export declare const devvitNotificationsPerAppPerDay = 25000;
 export declare function devvitNotificationTextLength(text: string): number;
 /**
 * The characters of a Devvit host code. The server bridge names a host code
-* in an error message as `(host code <code>)`, and the webview reads it back.
+* in an error message as `(host code <code>)`, and the webview reads it back,
+* both through `@mpgd/bridge/notifications` (`createNotificationsV2BridgeHandler`
+* and `readBridgeNotificationsHostCode`), whose pattern this equals.
 */
 export declare const devvitHostCodeCharacters = "[A-Za-z0-9_.:-]{1,128}";
 /** A post (`t3_`) or comment (`t1_`) id, the only links `enqueue` accepts. */

package/dist/notifications-contract.js

@@ -47,7 +47,9 @@ export function devvitNotificationTextLength(text) {
 }
 /**
  * The characters of a Devvit host code. The server bridge names a host code
- * in an error message as `(host code <code>)`, and the webview reads it back.
+ * in an error message as `(host code <code>)`, and the webview reads it back,
+ * both through `@mpgd/bridge/notifications` (`createNotificationsV2BridgeHandler`
+ * and `readBridgeNotificationsHostCode`), whose pattern this equals.
  */
 export const devvitHostCodeCharacters = '[A-Za-z0-9_.:-]{1,128}';
 /** A post (`t3_`) or comment (`t1_`) id, the only links `enqueue` accepts. */

package/dist/server/notifications-bridge.d.ts

@@ -1,4 +1,4 @@
-import { type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
+import type { BridgeRequest, BridgeResponse } from '@mpgd/bridge';
 import { type NotificationProvider } from '@mpgd/platform/notifications';
 /**
 * The game-rendered consent of the Devvit profile (notifications v2 RFC,
@@ -95,14 +95,17 @@ export interface DevvitNotificationsV2BridgeHandler {
 }
 /**
 * The server bridge side of notifications v2 on Devvit (RFC "Bridge and
-* versioning"): each method's payload and answer are checked with the
-* `@mpgd/bridge/notifications` validators. A payload the validator rejects
-* answers `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
+* versioning"): `createNotificationsV2BridgeHandler` from
+* `@mpgd/bridge/notifications` over the Devvit server provider. Each method's
+* payload and answer are checked with the `@mpgd/bridge/notifications`
+* validators. A payload the validator rejects answers
+* `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
 * local-notification methods) `NOTIFICATIONS_UNSUPPORTED`; `openSettings`
 * answers `unavailable`, because Devvit has no settings link; an answer the
 * contract rejects `NOTIFICATIONS_CONFIGURATION_REQUIRED`. A thrown
 * `NotificationError` crosses as `{ code, message, retryable }` with its host
-* code named in the message. Devvit has no server-to-webview event channel,
-* so the bridge carries no notifications events.
+* code named in the message, and an unexpected failure's text stays on the
+* server. Devvit has no server-to-webview event channel, so the bridge
+* carries no notifications events.
 */
 export declare function createDevvitNotificationsV2BridgeHandler(input: CreateDevvitNotificationsV2BridgeHandlerInput): DevvitNotificationsV2BridgeHandler;

package/dist/server/notifications-bridge.js

@@ -1,8 +1,6 @@
-import { createBridgeError, isBridgeNotificationsV2Method, } from '@mpgd/bridge';
-import { assertBridgeNotificationsV2Payload, assertBridgeNotificationsV2Result, } from '@mpgd/bridge/notifications';
-import { PlatformOperationError } from '@mpgd/platform';
-import { isNotificationErrorCode, NotificationError, notificationsProtocolVersion, } from '@mpgd/platform/notifications';
-import { createDevvitNotificationCapabilities, devvitHostCodeCharacters, devvitNotificationProviderId, devvitUserIdPattern, } from '../notifications-contract.js';
+import { createNotificationsV2BridgeHandler } from '@mpgd/bridge/notifications';
+import { NotificationError, } from '@mpgd/platform/notifications';
+import { createDevvitNotificationCapabilities, devvitNotificationProviderId, devvitUserIdPattern, } from '../notifications-contract.js';
 /** Host codes of the failures this provider normalizes. */
 export const devvitNotificationHostCodes = Object.freeze({
     optInRefused: 'DEVVIT_OPT_IN_REFUSED',
@@ -159,119 +157,31 @@ export function createDevvitServerNotificationProvider(input) {
 }
 /**
  * The server bridge side of notifications v2 on Devvit (RFC "Bridge and
- * versioning"): each method's payload and answer are checked with the
- * `@mpgd/bridge/notifications` validators. A payload the validator rejects
- * answers `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
+ * versioning"): `createNotificationsV2BridgeHandler` from
+ * `@mpgd/bridge/notifications` over the Devvit server provider. Each method's
+ * payload and answer are checked with the `@mpgd/bridge/notifications`
+ * validators. A payload the validator rejects answers
+ * `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
  * local-notification methods) `NOTIFICATIONS_UNSUPPORTED`; `openSettings`
  * answers `unavailable`, because Devvit has no settings link; an answer the
  * contract rejects `NOTIFICATIONS_CONFIGURATION_REQUIRED`. A thrown
  * `NotificationError` crosses as `{ code, message, retryable }` with its host
- * code named in the message. Devvit has no server-to-webview event channel,
- * so the bridge carries no notifications events.
+ * code named in the message, and an unexpected failure's text stays on the
+ * server. Devvit has no server-to-webview event channel, so the bridge
+ * carries no notifications events.
  */
 export function createDevvitNotificationsV2BridgeHandler(input) {
-    const provider = createDevvitServerNotificationProvider(input);
-    const onError = input.onError ?? ((error, context) => {
-        if (error instanceof NotificationError && error.code === 'NOTIFICATIONS_UNSUPPORTED') {
-            return;
-        }
-        console.warn(`devvit notifications ${context.method} failed`, error);
-    });
-    const serve = async (method, payload) => {
-        switch (method) {
-            case 'notifications.v2.getCapabilities':
-                validPayload(method, payload);
-                return {
-                    protocolVersion: notificationsProtocolVersion,
-                    provider: provider.provider,
-                    capabilities: await provider.getCapabilities(),
-                };
-            case 'notifications.v2.getPermission':
-                return provider.getPermission(validPayload(method, payload));
-            case 'notifications.v2.requestPermission':
-                return provider.requestPermission(validPayload(method, payload));
-            case 'notifications.v2.revokePermission':
-                return provider.revokePermission
-                    .call(provider, validPayload(method, payload));
-            case 'notifications.v2.register':
-                validPayload(method, payload);
-                return { registration: (await provider.register?.()) ?? null };
-            case 'notifications.v2.openSettings':
-                validPayload(method, payload);
-                return { status: 'unavailable' };
-            case 'notifications.v2.scheduleLocal':
-            case 'notifications.v2.cancelLocal':
-            case 'notifications.v2.listLocal':
-                validPayload(method, payload);
-                throw new NotificationError('NOTIFICATIONS_UNSUPPORTED', {
-                    message: `Devvit has no local notifications (${method}).`,
-                });
-        }
-    };
-    return {
-        async request(request) {
-            if (!isBridgeNotificationsV2Method(request.method)) {
-                return createBridgeError(request.id, 'UNSUPPORTED_METHOD', `${request.method} is not a notifications v2 method.`);
-            }
-            const method = request.method;
-            try {
-                const data = await serve(method, request.payload);
-                return { id: request.id, ok: true, data: validResult(method, data) };
-            }
-            catch (error) {
-                if (!(error instanceof InvalidPayloadError)) {
-                    try {
-                        const logged = onError(error, { method });
-                        if (logged instanceof Promise) {
-                            logged.catch(() => { });
-                        }
-                    }
-                    catch {
-                        // A failing log never changes the answer.
-                    }
-                }
-                return toBridgeError(request, error);
+    const handler = createNotificationsV2BridgeHandler({
+        provider: createDevvitServerNotificationProvider(input),
+        label: 'Devvit',
+        // An unexpected failure's text stays on the server.
+        unexpectedFailureMessage: (method) => `${method} failed on the Devvit server.`,
+        onError: input.onError ?? ((error, context) => {
+            if (error instanceof NotificationError && error.code === 'NOTIFICATIONS_UNSUPPORTED') {
+                return;
             }
-        },
-    };
-}
-class InvalidPayloadError extends Error {
-    name = 'InvalidPayloadError';
-}
-function validPayload(method, payload) {
-    try {
-        return assertBridgeNotificationsV2Payload(method, payload);
-    }
-    catch (error) {
-        throw new InvalidPayloadError(`${method} payload is invalid: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-}
-function validResult(method, data) {
-    try {
-        return assertBridgeNotificationsV2Result(method, data);
-    }
-    catch (error) {
-        throw new NotificationError('NOTIFICATIONS_CONFIGURATION_REQUIRED', {
-            message: `The Devvit notifications provider answered ${method} with invalid data: ${error instanceof Error ? error.message : String(error)}`,
-            cause: error,
-        });
-    }
-}
-const hostCodeValue = new RegExp(`^${devvitHostCodeCharacters}$`, 'u');
-function toBridgeError(request, error) {
-    if (error instanceof InvalidPayloadError) {
-        return createBridgeError(request.id, 'NOTIFICATIONS_INVALID_INPUT', error.message);
-    }
-    if (error instanceof NotificationError) {
-        return createBridgeError(request.id, error.code, error.hostCode === undefined || !hostCodeValue.test(error.hostCode)
-            ? error.message
-            : `${error.message} (host code ${error.hostCode})`, error.retryable);
-    }
-    if (error instanceof PlatformOperationError) {
-        return isNotificationErrorCode(error.code)
-            ? createBridgeError(request.id, error.code, error.message, error.retryable)
-            : createBridgeError(request.id, 'NOTIFICATIONS_TEMPORARILY_UNAVAILABLE', `${request.method} failed: ${error.message}`, error.retryable);
-    }
-    // An unexpected failure's text stays on the server.
-    return createBridgeError(request.id, 'NOTIFICATIONS_TEMPORARILY_UNAVAILABLE', `${request.method} failed on the Devvit server.`, true);
+            console.warn(`devvit notifications ${context.method} failed`, error);
+        }),
+    });
+    return { request: (request) => handler.request(request) };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-devvit",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "Reddit Devvit Web platform adapter for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -54,10 +54,10 @@
     "dist"
   ],
   "dependencies": {
-    "@devvit/web": "0.14.1",
-    "@mpgd/bridge": "0.14.3",
-    "@mpgd/platform": "0.27.1",
-    "@mpgd/game-services": "0.27.1"
+    "@devvit/web": "0.15.0",
+    "@mpgd/bridge": "0.15.0",
+    "@mpgd/platform": "0.27.2",
+    "@mpgd/game-services": "0.28.0"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",