Updates API, adds SKU service

desktop/src/app/environment/desktop-environment.ts

@@ -14,7 +14,7 @@ import { DefaultFormLayoutProvider } from "@azure/bonito-ui/lib/components/form"
 import { BrowserDependencyName, BrowserEnvironmentConfig, DefaultBrowserEnvironment } from "@azure/bonito-ui/lib/environment";
 import BatchExplorerHttpClient from "@batch-flask/core/batch-explorer-http-client";
 import { BatchBrowserDependencyFactories, BatchFormControlResolver } from "@batch/ui-react";
-import { LiveNodeService, LivePoolService } from "@batch/ui-service";
+import { LiveNodeService, LivePoolService, LiveSkuService } from "@batch/ui-service";
 import { BatchDependencyName } from "@batch/ui-service/lib/environment";
 import { DesktopLocalizer } from "app/localizer/desktop-localizer";
 import { AppTranslationsLoaderService, AuthService, BatchExplorerService } from "app/services";
@@ -46,6 +46,8 @@ export function initDesktopEnvironment(
                 new LivePoolService(),
             [BatchDependencyName.NodeService]: () =>
                 new LiveNodeService(),
+            [BatchDependencyName.SkuService]: () =>
+                new LiveSkuService(),
             [DependencyName.Notifier]: () =>
                 new AlertNotifier(), // TODO: update with real notification implementation
             [DependencyName.ResourceGroupService]: () =>

packages/bonito-core/i18n/resources.resjson

@@ -6,6 +6,7 @@
   "bonito.core.close": "Close",
   "bonito.core.form.validation.booleanValueError": "Value must be a boolean",
   "bonito.core.form.validation.invalidEnumValue": "Invalid value",
+  "bonito.core.form.validation.minLengthError": "Value must be at least {length} characters long",
   "bonito.core.form.validation.numberValueError": "Value must be a number",
   "bonito.core.form.validation.stringListValueError": "All values must be strings",
   "bonito.core.form.validation.stringValueError": "Value must be a string",

packages/bonito-core/src/__tests__/http-localizer.spec.ts

@@ -4,39 +4,42 @@ describe("HttpLocalizer", () => {
     let httpLocalizer: HttpLocalizer;
     let fetchMock: jest.Mock;
 
-    const testTranslations = { hello: "world" };
+    const testTranslations = {
+        hello: "world",
+        parameterized: "Hello, {name}",
+    };
     const frenchTranslations = { bonjour: "monde" };
 
+    const setUpTranslations = (
+        translations: { [key: string]: string } = testTranslations,
+        locale = "en-US"
+    ) => {
+        fetchMock.mockImplementationOnce(() =>
+            Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve(translations),
+            })
+        );
+        jest.spyOn(httpLocalizer, "getLocale").mockReturnValue(locale);
+    };
+
     beforeEach(() => {
         httpLocalizer = new HttpLocalizer();
         fetchMock = jest.fn();
         global.fetch = fetchMock;
     });
 
     test("Load the correct translation file based on the locale", async () => {
-        fetchMock.mockImplementationOnce(() =>
-            Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve(testTranslations),
-            })
-        );
+        setUpTranslations();
 
-        jest.spyOn(httpLocalizer, "getLocale").mockReturnValue("en-US");
         await httpLocalizer.loadTranslations("/base/url");
         expect(fetchMock).toHaveBeenCalledWith("/base/url/resources.en.json");
         expect(httpLocalizer.translate("hello")).toEqual("world");
     });
 
     test("Load the correct translation file for French locale", async () => {
-        fetchMock.mockImplementationOnce(() =>
-            Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve(frenchTranslations),
-            })
-        );
+        setUpTranslations(frenchTranslations, "fr-FR");
 
-        // Simulate a French locale
-        jest.spyOn(httpLocalizer, "getLocale").mockReturnValue("fr-FR");
         await httpLocalizer.loadTranslations("/resources/i18n");
         expect(fetchMock).toHaveBeenCalledWith(
             "/resources/i18n/resources.fr.json"
@@ -45,15 +48,9 @@ describe("HttpLocalizer", () => {
     });
 
     test("Default to English if locale not found", async () => {
-        fetchMock.mockImplementationOnce(() =>
-            Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve(testTranslations),
-            })
-        );
-
         // Simulate an invalid locale
-        jest.spyOn(httpLocalizer, "getLocale").mockReturnValue("abc");
+        setUpTranslations(testTranslations, "abc");
+
         await httpLocalizer.loadTranslations("/resources/i18n");
         expect(fetchMock).toHaveBeenCalledWith(
             "/resources/i18n/resources.en.json"
@@ -68,15 +65,18 @@ describe("HttpLocalizer", () => {
     });
 
     test("Return original message if no translation found", async () => {
-        fetchMock.mockImplementationOnce(() =>
-            Promise.resolve({
-                ok: true,
-                json: () => Promise.resolve(testTranslations),
-            })
-        );
+        setUpTranslations();
 
-        jest.spyOn(httpLocalizer, "getLocale").mockReturnValue("en-US");
         await httpLocalizer.loadTranslations("/resources/i18n");
         expect(httpLocalizer.translate("notFound")).toEqual("notFound");
     });
+
+    test("Supports parameterized translations", async () => {
+        setUpTranslations();
+
+        await httpLocalizer.loadTranslations("/base/url");
+        expect(
+            httpLocalizer.translate("parameterized", { name: "world" })
+        ).toEqual("Hello, world");
+    });
 });

packages/bonito-core/src/__tests__/localization.spec.ts

@@ -1,5 +1,5 @@
 import { initMockEnvironment } from "../environment";
-import { translate } from "../localization/localization-util";
+import { replaceTokens, translate } from "../localization/localization-util";
 import { LocalizedStrings } from "../localization/localized-strings";
 
 describe("Localization utilities", () => {
@@ -13,9 +13,65 @@ describe("Localization utilities", () => {
         ).toEqual("Value must be a boolean");
     });
 
-    test("Throw error if string is unknown", () => {
+    test("Throws error if string is unknown", () => {
         expect(() =>
             translate("Invalid" as unknown as keyof LocalizedStrings)
         ).toThrowError("Unable to translate string Invalid");
     });
+
+    test("Can translate parameterized strings", () => {
+        expect(
+            translate("bonito.core.form.validation.minLengthError", {
+                length: 5,
+            })
+        ).toEqual("Value must be at least 5 characters long");
+    });
+
+    describe("Token replacer", () => {
+        test("Can replace a single token", () => {
+            expect(replaceTokens("Hello {name}", { name: "World" })).toEqual(
+                "Hello World"
+            );
+        });
+        test("Ignores unknown tokens", () => {
+            expect(replaceTokens("Hello {name}", {})).toEqual("Hello {name}");
+        });
+        test("Can replace multiple tokens", () => {
+            expect(
+                replaceTokens("{emotion} is the {organ} {role}", {
+                    emotion: "Fear",
+                    organ: "mind",
+                    role: "killer",
+                })
+            ).toEqual("Fear is the mind killer");
+        });
+        test("Ignores unparametrized strings", () => {
+            expect(replaceTokens("Hello World", { name: "World" })).toEqual(
+                "Hello World"
+            );
+        });
+        test("Handles non-string tokens", () => {
+            expect(replaceTokens("Who is my #{num}?", { num: 5 })).toEqual(
+                "Who is my #5?"
+            );
+            expect(
+                replaceTokens("Too good to be {state}", { state: true })
+            ).toEqual("Too good to be true");
+            expect(
+                replaceTokens("Bear {truth} witness", { truth: false })
+            ).toEqual("Bear false witness");
+        });
+        test("Handles multiple instances of the same token", () => {
+            expect(
+                replaceTokens("{name} is the name of my {name}", {
+                    name: "cat",
+                })
+            ).toEqual("cat is the name of my cat");
+        });
+        test("Handles whitespace around tokens", () => {
+            expect(replaceTokens("Hello { name }", { name: "World" })).toEqual(
+                "Hello World"
+            );
+        });
+    });
 });

packages/bonito-core/src/form/form.i18n.yml

@@ -5,3 +5,4 @@ form:
     numberValueError: Value must be a number
     stringListValueError: All values must be strings
     stringValueError: Value must be a string
+    minLengthError: Value must be at least {length} characters long

packages/bonito-core/src/localization/fake-localizer.ts

@@ -1,4 +1,5 @@
-import { Localizer } from "./localizer";
+import { replaceTokens } from "./localization-util";
+import { Localizer, LocalizerTokenMap } from "./localizer";
 
 export class FakeLocalizer implements Localizer {
     private locale: string;
@@ -7,14 +8,17 @@ export class FakeLocalizer implements Localizer {
         this.locale = "en";
     }
 
-    translate(message: string): string {
+    translate(message: string, tokens?: LocalizerTokenMap): string {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const value = (globalThis as unknown as any).__TEST_RESOURCE_STRINGS[
             message
         ];
         if (value == null) {
             throw new Error("Unable to translate string " + message);
         }
+        if (tokens) {
+            return replaceTokens(value, tokens);
+        }
         return value;
     }
 

packages/bonito-core/src/localization/http-localizer.ts

@@ -1,4 +1,5 @@
-import { Localizer } from "./localizer";
+import { replaceTokens } from "./localization-util";
+import { Localizer, LocalizerTokenMap } from "./localizer";
 
 interface Translations {
     [key: string]: string;
@@ -85,12 +86,32 @@ export class HttpLocalizer implements Localizer {
         return await response.json();
     }
 
-    translate(message: string): string {
+    /**
+     * Translates a message using loaded translations and optional tokens.
+     *
+     * @param {string} message - The message to be translated.
+     * @param {LocalizerTokenMap} [tokens] - An optional map of tokens to replace in the translation.
+     * @returns {string} The translated message, or the original message if no translation was found.
+     * @throws {Error} If the translations have not been loaded.
+     *
+     * @example
+     * ```yaml
+     * foo: My name is {name}
+     * ```
+     *
+     * ```typescript
+     * translate("foo", { name: "Lucy Barton" }) // "My name is Lucy Barton"
+     * ```
+     */
+    translate(message: string, tokens?: LocalizerTokenMap): string {
         if (!this.translations) {
             throw new Error("Translation strings are not loaded " + message);
         }
         const translation = this.translations[message];
         if (translation != null) {
+            if (tokens) {
+                return replaceTokens(translation, tokens);
+            }
             return translation;
         } else {
             return message;

packages/bonito-core/src/localization/localization-util.ts

@@ -1,15 +1,23 @@
 import { getEnvironment } from "../environment";
 import { LocalizedStrings } from "./localized-strings";
-import { Localizer } from "./localizer";
+import { Localizer, LocalizerTokenMap } from "./localizer";
 
 export function translate(
-    message: Extract<keyof LocalizedStrings, string>
+    message: Extract<keyof LocalizedStrings, string>,
+    tokens?: LocalizerTokenMap
 ): string {
     return getLocalizer().translate(
-        message as unknown as keyof LocalizedStrings
+        message as unknown as keyof LocalizedStrings,
+        tokens
     );
 }
 
 export function getLocalizer(): Localizer {
     return getEnvironment().getLocalizer();
 }
+
+export function replaceTokens(text: string, tokens: LocalizerTokenMap): string {
+    return text.replace(/{\s*([\w.]+)\s*}/g, (match, token) =>
+        token in tokens ? String(tokens[token]) : match
+    );
+}

packages/bonito-core/src/localization/localizer.ts

@@ -1,4 +1,6 @@
+export type LocalizerTokenMap = Record<string, string | number | boolean>;
+
 export interface Localizer {
-    translate(message: string): string;
+    translate(message: string, tokens?: LocalizerTokenMap): string;
     getLocale(): string;
 }

packages/service/i18n/resources.resjson

@@ -1 +1,4 @@
-{}
+{
+  "lib.service.sku.eolWarning": "This SKU is scheduled for retirement on {eolDate}",
+  "lib.service.sku.notFound": "SKU '{skuName}' not found"
+}

packages/service/src/constants.ts

@@ -1,4 +1,4 @@
 export const BatchApiVersion = {
-    arm: `2023-11-01`,
+    arm: `2024-02-01`,
     data: `2023-05-01.17.0`,
 };

packages/service/src/environment/batch-dependencies.ts

@@ -1,13 +1,16 @@
 import { DependencyFactories } from "@azure/bonito-core/lib/environment";
 import { NodeService } from "../node";
 import { PoolService } from "../pool";
+import { SkuService } from "../sku";
 
 export enum BatchDependencyName {
     PoolService = "poolService",
     NodeService = "nodeService",
+    SkuService = "skuService",
 }
 
 export interface BatchDependencyFactories extends DependencyFactories {
     [BatchDependencyName.PoolService]: () => PoolService;
     [BatchDependencyName.NodeService]: () => NodeService;
+    [BatchDependencyName.SkuService]: () => SkuService;
 }

packages/service/src/environment/environment-util.ts

@@ -7,13 +7,15 @@ import {
     mockEnvironmentConfig,
 } from "@azure/bonito-core/lib/environment";
 import { FakePoolService } from "../pool";
+import { FakeSkuService } from "../sku";
 import {
     BatchDependencyFactories,
     BatchDependencyName,
 } from "./batch-dependencies";
 
 export const mockBatchDepFactories: Partial<BatchDependencyFactories> = {
     [BatchDependencyName.PoolService]: () => new FakePoolService(),
+    [BatchDependencyName.SkuService]: () => new FakeSkuService(),
 };
 
 /**

packages/service/src/index.ts

@@ -4,3 +4,4 @@ export * from "./certificate";
 export * from "./pool";
 export * from "./node";
 export * from "./constants";
+export * from "./sku";

packages/service/src/internal/arm-batch-rest/generated/batchManagementClient.ts

@@ -14,7 +14,7 @@ export default function createClient(
   options: ClientOptions = {}
 ): BatchManagementClient {
   const baseUrl = options.baseUrl ?? `https://management.azure.com`;
-  options.apiVersion = options.apiVersion ?? "2023-11-01";
+  options.apiVersion = options.apiVersion ?? "2024-02-01";
   options = {
     ...options,
     credentials: {