@whooshbang/contract-mock 2.0.0-rc.4 → 2.0.0-rc.5

package/CHANGELOG.md

@@ -5,6 +5,12 @@ recorded here.
 
 ## Unreleased
 
+## 2.0.0-rc.5
+
+### Changed
+
+- Route a message the way the service does: a chosen `connection_id` is honored, and with none the subscriber's preferred channel, else the default connection when connected there, else the most recently connected one. A chosen connection that is unknown, archived or paused is `request_invalid` at `/connection_id`; one the subscriber never connected through is `subscriber_not_connected` (FXO-2865).
+
 ## 2.0.0-rc.4
 
 ### Changed

package/dist/core.js

@@ -1413,6 +1413,10 @@ function problem(code, status, diagnosticId, overrides = {}) {
         ...(overrides.provider_failure === undefined
             ? {}
             : { provider_failure: overrides.provider_failure }),
+        ...(overrides.channel === undefined ? {} : { channel: overrides.channel }),
+        ...(overrides.subscriber_id === undefined
+            ? {}
+            : { subscriber_id: overrides.subscriber_id }),
     };
     if (!validateProblem(value)) {
         throw new Error("Internal contract-mock Problem Details violation.");
@@ -2032,6 +2036,8 @@ function normalizeMessageRequest(request) {
     };
 }
 function messageDeliveryTarget(request, environment) {
+    if (request.connection_id !== undefined)
+        return "connection";
     return (request.delivery_target ??
         (environment === "test" &&
             SIMULATOR_DESTINATIONS.has(request.to.subscriber_id)
@@ -2055,21 +2061,20 @@ function simulatorBinding(state, credential, subscriberId, notifierId) {
     return binding;
 }
 /**
- * Resolves one exact provider binding without sorting across connections.
+ * Resolves the one binding a send reaches, by the service's rule (FXO-2865).
  *
- * The notifier route selects the connection that may deliver. Later consent
- * on another connection remains valid but is never selected by sorting. A
- * converted-v1 binding remains eligible only when the subscriber has no
- * connection-bound candidate.
+ * A named connection is the only one used. Otherwise the recipient's
+ * preference is the only one used; otherwise the default connection when the
+ * subscriber is connected there; otherwise the connection they connected
+ * through most recently, which here is the last one recorded. A converted-v1
+ * binding remains eligible only when the subscriber has no connection-bound
+ * candidate.
  */
 function connectionBinding(state, credential, subscriberId, notifierId, connectionId) {
     const routeKey = notifierConnectionKey(credential.projectId, credential.environment, notifierId);
     const defaultConnectionId = state.notifierDefaultConnections.get(routeKey);
     const isExecutable = (binding) => {
-        if (binding.connection_id === undefined ||
-            binding.connection_id !== (connectionId ?? defaultConnectionId) ||
-            !(state.notifierConnections.get(routeKey)?.has(binding.connection_id) ??
-                false)) {
+        if (binding.connection_id === undefined) {
             return false;
         }
         const record = state.channelConnections.get(binding.connection_id);
@@ -2107,9 +2112,13 @@ function connectionBinding(state, credential, subscriberId, notifierId, connecti
             state.recipientConnectionIds.has(subscriberGroupKey(credential.projectId, credential.environment, preference.connection_id)));
     }
     const connectionBound = candidates.filter((binding) => binding.connection_id !== undefined);
-    const defaultBindings = connectionBound.filter((binding) => isExecutable(binding));
-    if (defaultBindings.length === 1) {
-        return defaultBindings[0];
+    const executable = connectionBound.filter((binding) => isExecutable(binding));
+    const onDefault = executable.find((binding) => binding.connection_id === defaultConnectionId);
+    if (onDefault !== undefined) {
+        return onDefault;
+    }
+    if (executable.length > 0) {
+        return executable[executable.length - 1];
     }
     if (connectionBound.length > 0) {
         return undefined;
@@ -6022,8 +6031,52 @@ function addPublicRoutes(app, getState, options) {
         }
         const matchingBinding = deliveryTarget === "simulator"
             ? simulatorBinding(state, credential, normalized.to.subscriber_id, notifierId)
-            : connectionBinding(state, credential, normalized.to.subscriber_id, notifierId, exactConnectionTest ? normalized.connection_id : undefined);
+            : connectionBinding(state, credential, normalized.to.subscriber_id, notifierId, normalized.connection_id);
         if (matchingBinding === undefined) {
+            // A chosen connection is the sender's, not the recipient's: say which
+            // one the subscriber is not connected through (FXO-2865).
+            const chosen = normalized.connection_id === undefined || exactConnectionTest
+                ? undefined
+                : state.channelConnections.get(normalized.connection_id);
+            // Not connected anywhere is still subscriber_unbound below, as on the
+            // service; subscriber_not_connected names a subscriber connected
+            // somewhere else.
+            const connectedElsewhere = normalized.connection_id !== undefined &&
+                !exactConnectionTest &&
+                connectionBinding(state, credential, normalized.to.subscriber_id, notifierId) !== undefined;
+            if (normalized.connection_id !== undefined && !exactConnectionTest) {
+                if (chosen === undefined ||
+                    chosen.ownerOrganizationId !== credential.organizationId ||
+                    chosen.connection.project_id !== credential.projectId ||
+                    chosen.connection.status === "archived")
+                    return problemResponse({
+                        ...problem("request_invalid", 400, state.idGenerator("diagnostic")),
+                        field_errors: [
+                            {
+                                code: "connection_not_found",
+                                detail: "No connection with this ID exists in this environment.",
+                                field: "/connection_id",
+                            },
+                        ],
+                    });
+                if (chosen.connection.status !== "active" &&
+                    chosen.connection.status !== "degraded")
+                    return problemResponse({
+                        ...problem("request_invalid", 400, state.idGenerator("diagnostic")),
+                        field_errors: [
+                            {
+                                code: "connection_not_sending",
+                                detail: "This connection is paused or not finished setting up, so it cannot send.",
+                                field: "/connection_id",
+                            },
+                        ],
+                    });
+                if (connectedElsewhere)
+                    return problemResponse(problem("subscriber_not_connected", 422, state.idGenerator("diagnostic"), {
+                        channel: chosen.connection.provider,
+                        subscriber_id: normalized.to.subscriber_id,
+                    }));
+            }
             if (state.preferences.has(recipientPreferenceKey(credential.projectId, credential.environment, normalized.to.subscriber_id, notifierId))) {
                 return problemResponse(problem("preferred_binding_unavailable", 422, state.idGenerator("diagnostic")));
             }
@@ -7263,11 +7316,10 @@ function addPublicRoutes(app, getState, options) {
                 record.binding.connection_id === connection.connection.id &&
                 record.binding.status === "active")?.binding;
             if (!binding)
-                return problemResponse({
-                    ...problem("subscriber_not_connected", 422, state.idGenerator("diagnostic")),
+                return problemResponse(problem("subscriber_not_connected", 422, state.idGenerator("diagnostic"), {
                     channel: connection.connection.provider,
                     subscriber_id: input.to.subscriber_id,
-                });
+                }));
             // A connection test is authorized by connections:write. The internal
             // message admission carries the same tenant and exact bound connection;
             // it does not grant a reusable messages:write credential to the caller.