Add support for region-based feature flags

Author: thsparks

localtypings/pxtarget.d.ts

@@ -327,6 +327,11 @@ declare namespace pxt {
         skipCloudBuild?: boolean;
     }
 
+    interface FeatureFlag {
+        includeRegions?: string[];
+        excludeRegions?: string[];
+    }
+
     interface AppTheme {
         id?: string;
         name?: string;
@@ -503,8 +508,6 @@ declare namespace pxt {
         tutorialExplicitHints?: boolean; // allow use explicit hints
         errorList?: boolean; // error list experiment
         embedBlocksInSnapshot?: boolean; // embed blocks xml in right-click snapshot
-        blocksErrorList?: boolean; // blocks error list
-        aiErrorHelp?: boolean; // Enable AI assistance for errors
         identity?: boolean; // login with identity providers
         assetEditor?: boolean; // enable asset editor view (in blocks/text toggle)
         disableMemoryWorkspaceWarning?: boolean; // do not warn the user when switching to in memory workspace
@@ -530,6 +533,7 @@ declare namespace pxt {
         timeMachineSnapshotInterval?: number; // An interval in milliseconds at which to take full project snapshots in project history. Defaults to 15 minutes
         adjustBlockContrast?: boolean; // If set to true, all block colors will automatically be adjusted to have a contrast ratio of 4.5 with text
         pxtJsonOptions?: PxtJsonOption[];
+        enabledFeatures?: pxt.Map<FeatureFlag>;
     }
 
     interface DownloadDialogTheme {

pxtlib/cloud.ts

@@ -7,6 +7,8 @@ namespace pxt.cloud {
 
     type BackendUrls = typeof DEV_BACKEND_PROD | typeof DEV_BACKEND_STAGING | typeof DEV_BACKEND_LOCALHOST;
     export const DEV_BACKEND: BackendUrls = DEV_BACKEND_STAGING;
+    export const DEV_REGION = "US";
+
 
     export function devBackendType(): DevBackendType {
         if (DEV_BACKEND === DEV_BACKEND_PROD) return "prod";

pxtlib/emitter/cloud.ts

@@ -8,6 +8,7 @@ namespace pxt.Cloud {
     export let localToken = "";
     let _isOnline = true;
     export let onOffline = () => { };
+    let region: string = undefined;
 
     function offlineError(url: string) {
         let e: any = new Error(Util.lf("Cannot access {0} while offline", url));
@@ -310,6 +311,38 @@ namespace pxt.Cloud {
         return undefined;
     }
 
+    export async function initRegionAsync(): Promise<void> {
+        if (BrowserUtils.isLocalHost()) {
+            region = cloud.DEV_REGION;
+            return;
+        }
+
+        if (region !== undefined || !pxt.webConfig?.cdnUrl) {
+            return;
+        }
+
+        const url = new URL("geo", pxt.webConfig.cdnUrl).toString();
+        const options: Util.HttpRequestOptions = { url };
+
+        try {
+            const response = await Util.requestAsync(options);
+            if (response.statusCode !== 200) {
+                pxt.error(`Failed to get region: ${response.statusCode}`);
+            }
+            region = response.text.trim();
+        } catch (e) {
+            handleNetworkError(options, e);
+        }
+    }
+
+    export function getRegion(): string {
+        if (!region) {
+            pxt.error("Accessing region before it is initialized. Call initRegionAsync first.");
+        }
+
+        return region;
+    }
+
     //
     // Interfaces used by the cloud
     //

pxtlib/util.ts

@@ -1893,6 +1893,27 @@ namespace ts.pxtc.Util {
             }
         }
     }
+
+    /**
+     * Check if the specified feature is enabled for the user (based on pxtarget configuration and region).
+     */
+    export function isFeatureEnabled(featureKey: string): boolean {
+        const feature = pxt.appTarget.appTheme?.enabledFeatures?.[featureKey];
+        if (!feature) return false;
+
+        let enabled = true;
+        const regionNormalised = pxt.Cloud.getRegion() ? pxt.Cloud.getRegion().toUpperCase() : undefined;
+        if (feature.includeRegions) {
+            enabled = regionNormalised && feature.includeRegions.some(r => r.toUpperCase() == regionNormalised);
+        }
+
+        // Include and exclude shouldn't really be used together, but if they are, exclude takes precedence
+        if (enabled && feature.excludeRegions) {
+            enabled = regionNormalised && !feature.excludeRegions.some(r => r.toUpperCase() == regionNormalised);
+        }
+
+        return enabled;
+    }
 }
 
 namespace ts.pxtc.BrowserImpl {

webapp/src/app.tsx

@@ -6312,6 +6312,8 @@ document.addEventListener("DOMContentLoaded", async () => {
                 baseUrl: baseUrl,
                 code: useLang,
                 force: force,
+            }).then(async () => {
+                return pxt.Cloud.initRegionAsync();
             }).then(() => {
                 if (pxt.Util.isLocaleEnabled(useLang)) {
                     pxt.BrowserUtils.setCookieLang(useLang);

webapp/src/blocks.tsx

@@ -932,7 +932,7 @@ export class Editor extends toolboxeditor.ToolboxEditor {
 
     display(): JSX.Element {
         let flyoutOnly = this.parent.state.editorState && this.parent.state.editorState.hasCategories === false;
-        let showErrorList = pxt.appTarget.appTheme.blocksErrorList;
+        let showErrorList = pxt.Util.isFeatureEnabled("blocksErrorList");
         return (
             <div className="blocksAndErrorList">
                 <div className="blocksEditorOuter">

webapp/src/errorList.tsx

@@ -104,7 +104,7 @@ export class ErrorList extends auth.Component<ErrorListProps, ErrorListState> {
         const errorCount = errors.length;
         const canDebug = startDebugger && !!errors.find(a => a.stackFrames?.length);
 
-        const showErrorHelp = !!getErrorHelp && !!showLoginDialog && pxt.appTarget.appTheme.aiErrorHelp;
+        const showErrorHelp = !!getErrorHelp && !!showLoginDialog && pxt.Util.isFeatureEnabled("aiErrorHelp");
 
         const helpLoader = (
             <div className="error-help-loader" onClick={(e) => e.stopPropagation()}>