From a814deef81bd62ae7f64050f5c935e3923e4d994 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Fri, 27 Sep 2024 18:10:52 +0200
Subject: [PATCH 01/13] refactor(registry): move updateTemplate logic into the
 repo

---
 registry/package-lock.json                    |  7 ++
 registry/package.json                         |  1 +
 registry/server/templates/interfaces/index.ts | 13 ++-
 .../server/templates/routes/createTemplate.ts |  4 +-
 .../templates/routes/getRenderedTemplate.ts   |  4 +-
 .../server/templates/routes/updateTemplate.ts | 53 +++++-----
 .../server/templates/routes/validation.ts     | 24 +++--
 .../templates/services/templatesRepository.ts | 98 ++++++++++++++++---
 8 files changed, 153 insertions(+), 51 deletions(-)

diff --git a/registry/package-lock.json b/registry/package-lock.json
index 121fe76c1..6335803e1 100644
--- a/registry/package-lock.json
+++ b/registry/package-lock.json
@@ -39,6 +39,7 @@
                 "serve-static": "^1.16.2",
                 "source-map-support": "^0.5.21",
                 "sqlite3": "^5.1.7",
+                "ts-exhaustive-check": "^1.0.0",
                 "url-join": "^4.0.1",
                 "uuid": "^9.0.1"
             },
@@ -8556,6 +8557,12 @@
                 "node": ">= 14.0.0"
             }
         },
+        "node_modules/ts-exhaustive-check": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/ts-exhaustive-check/-/ts-exhaustive-check-1.0.0.tgz",
+            "integrity": "sha512-sKNyrdJfB1nsPMip5+xSKPdwuZ8XZ1WgxGw3ho4qXGlUQ4BGmmS0voGBK0ecimcvqzhVk84RF4JOhtZEIJWiNw==",
+            "license": "MIT"
+        },
         "node_modules/ts-node": {
             "version": "10.9.2",
             "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
diff --git a/registry/package.json b/registry/package.json
index 18d82b980..0cfa5efde 100644
--- a/registry/package.json
+++ b/registry/package.json
@@ -95,6 +95,7 @@
         "serve-static": "^1.16.2",
         "source-map-support": "^0.5.21",
         "sqlite3": "^5.1.7",
+        "ts-exhaustive-check": "^1.0.0",
         "url-join": "^4.0.1",
         "uuid": "^9.0.1"
     },
diff --git a/registry/server/templates/interfaces/index.ts b/registry/server/templates/interfaces/index.ts
index 665aad1db..cf0f84a90 100644
--- a/registry/server/templates/interfaces/index.ts
+++ b/registry/server/templates/interfaces/index.ts
@@ -3,8 +3,19 @@ export default interface Template {
     content: string;
 }
 
-export interface LocalizedTemplate {
+export interface LocalizedTemplateRow {
     templateName: string;
     content: string;
     locale: string;
 }
+
+export interface LocalizedVersion {
+    content: string;
+}
+
+export interface TemplateWithLocalizedVersions extends Template {
+    localizedVersions: Record<string, LocalizedVersion>;
+}
+
+export type UpdateTemplatePayload = Omit<Template, 'name' | 'localizedVersions'> &
+    Partial<Pick<TemplateWithLocalizedVersions, 'localizedVersions'>>;
diff --git a/registry/server/templates/routes/createTemplate.ts b/registry/server/templates/routes/createTemplate.ts
index d106f4fbc..82cce0be6 100644
--- a/registry/server/templates/routes/createTemplate.ts
+++ b/registry/server/templates/routes/createTemplate.ts
@@ -2,7 +2,7 @@ import { Request, Response } from 'express';
 
 import db from '../../db';
 import validateRequestFactory from '../../common/services/validateRequest';
-import Template, { LocalizedTemplate } from '../interfaces';
+import Template, { LocalizedTemplateRow } from '../interfaces';
 import { Tables } from '../../db/structure';
 import { templatesRepository } from '../services/templatesRepository';
 import { templateSchema, validateLocalesAreSupported } from './validation';
@@ -46,7 +46,7 @@ const createTemplate = async (req: Request, res: Response): Promise<void> => {
 function insertLocalizedVersions(locales: string[], template: Template, request: Record<string, any>) {
     return Promise.all(
         locales.map((locale) => {
-            const localizedTemplate: LocalizedTemplate = {
+            const localizedTemplate: LocalizedTemplateRow = {
                 templateName: template.name,
                 content: request.localizedVersions[locale].content,
                 locale: locale,
diff --git a/registry/server/templates/routes/getRenderedTemplate.ts b/registry/server/templates/routes/getRenderedTemplate.ts
index 0f98221ba..0d83a44b0 100644
--- a/registry/server/templates/routes/getRenderedTemplate.ts
+++ b/registry/server/templates/routes/getRenderedTemplate.ts
@@ -3,7 +3,7 @@ import Joi from 'joi';
 
 import noticeError from '../../errorHandler/noticeError';
 import db from '../../db';
-import Template, { LocalizedTemplate } from '../interfaces';
+import Template, { LocalizedTemplateRow } from '../interfaces';
 import validateRequestFactory from '../../common/services/validateRequest';
 import renderTemplate from '../services/renderTemplate';
 import errors from '../errors';
@@ -89,7 +89,7 @@ async function getRenderedTemplate(req: Request<GetTemplateRenderedRequestParams
     if (locale) {
         const [localizedTemplate] = await db
             .select()
-            .from<LocalizedTemplate>(Tables.TemplatesLocalized)
+            .from<LocalizedTemplateRow>(Tables.TemplatesLocalized)
             .where('templateName', templateName)
             .andWhere('locale', locale as string);
 
diff --git a/registry/server/templates/routes/updateTemplate.ts b/registry/server/templates/routes/updateTemplate.ts
index 5c7ab54ba..fe0deaa9c 100644
--- a/registry/server/templates/routes/updateTemplate.ts
+++ b/registry/server/templates/routes/updateTemplate.ts
@@ -1,10 +1,11 @@
 import { Request, Response } from 'express';
 import Joi from 'joi';
+import { exhaustiveCheck } from 'ts-exhaustive-check';
 
-import db from '../../db';
 import validateRequestFactory from '../../common/services/validateRequest';
+import { joiErrorToResponse } from '../../util/helpers';
 import { templatesRepository } from '../services/templatesRepository';
-import { partialTemplateSchema, templateNameSchema, validateLocalesAreSupported } from './validation';
+import { partialTemplateSchema, templateNameSchema, unsupportedLocalesToJoiError } from './validation';
 
 type UpdateTemplateRequestParams = {
     name: string;
@@ -24,32 +25,30 @@ const validateRequestBeforeUpdateTemplate = validateRequestFactory([
 ]);
 
 const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Response): Promise<void> => {
-    const template = {
-        content: req.body.content,
-    };
-    const templateName = req.params.name;
-
-    const templatesToUpdate = await db('templates').where({
-        name: templateName,
-    });
-    if (!templatesToUpdate.length) {
-        res.status(404).send('Not found');
-        return;
-    }
-
-    const localizedVersions = req.body.localizedVersions || {};
-    const localesAreValid = await validateLocalesAreSupported(Object.keys(localizedVersions), res);
-    if (!localesAreValid) {
-        return;
+    const result = await templatesRepository.updateTemplate(
+        req.params.name,
+        req.body,
+        // TODO: cheeck if user here is really required
+        req.user!,
+    );
+
+    switch (result.type) {
+        case 'notFound': {
+            res.status(404).send('Not found');
+            return;
+        }
+        case 'localeNotSupported': {
+            res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError(result.locales)));
+            return;
+        }
+        case 'ok': {
+            res.status(200).send(result.template);
+            return;
+        }
+        default: {
+            exhaustiveCheck(result);
+        }
     }
-
-    await db.versioning(req.user, { type: 'templates', id: templateName }, async (trx) => {
-        await db('templates').where({ name: templateName }).update(template).transacting(trx);
-        await templatesRepository.upsertLocalizedVersions(templateName, localizedVersions, trx);
-    });
-
-    const updatedTemplate = await templatesRepository.readTemplateWithAllVersions(templateName);
-    res.status(200).send(updatedTemplate);
 };
 
 export default [validateRequestBeforeUpdateTemplate, updateTemplate];
diff --git a/registry/server/templates/routes/validation.ts b/registry/server/templates/routes/validation.ts
index d0f1e03f8..f571e97d6 100644
--- a/registry/server/templates/routes/validation.ts
+++ b/registry/server/templates/routes/validation.ts
@@ -47,16 +47,24 @@ export const templateSchema = Joi.object({
     localizedVersions,
 });
 
-export async function validateLocalesAreSupported(locales: string[], res: Response) {
+export async function getUnsupportedLocales(locales: string[]): Promise<string[]> {
     const supportedLocales = await settingsService.get(SettingKeys.I18nSupportedLocales);
-    let unsupportedLocales = locales.filter((l) => !supportedLocales.includes(l));
+    return locales.filter((l) => !supportedLocales.includes(l));
+}
+
+export function unsupportedLocalesToJoiError(unsupportedLocales: string[]): Joi.ValidationError {
+    return getJoiErr(
+        `localizedVersions.${unsupportedLocales[0]}`,
+        `Next locales are not supported ${unsupportedLocales.join(',')}. Either change request or change ${
+            SettingKeys.I18nSupportedLocales
+        } setting.`,
+    );
+}
+
+export async function validateLocalesAreSupported(locales: string[], res: Response) {
+    const unsupportedLocales = await getUnsupportedLocales(locales);
     if (unsupportedLocales.length > 0) {
-        let joiError = getJoiErr(
-            `localizedVersions.${unsupportedLocales[0]}`,
-            `Next locales are not supported ${unsupportedLocales.join(',')}. Either change request or change ${
-                SettingKeys.I18nSupportedLocales
-            } setting.`,
-        );
+        const joiError = unsupportedLocalesToJoiError(unsupportedLocales);
         res.status(422);
         res.send(joiErrorToResponse(joiError));
         return false;
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index 3045893cc..0692bd37a 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -1,15 +1,21 @@
-import { ok } from 'assert';
 import { Knex } from 'knex';
 
 import { PaginatedResult } from '../../../typings/PaginatedResult';
 import db, { VersionedKnex } from '../../db';
 import { Tables } from '../../db/structure';
 import { appendDigest } from '../../util/hmac';
-import { EntityTypes } from '../../versioning/interfaces';
-import Template, { LocalizedTemplate } from '../interfaces';
+import { normalizeArray } from '../../util/normalizeArray';
+import { EntityTypes, VersionedRecord } from '../../versioning/interfaces';
+import Template, {
+    LocalizedTemplateRow,
+    LocalizedVersion,
+    TemplateWithLocalizedVersions,
+    UpdateTemplatePayload,
+} from '../interfaces';
 
 import Transaction = Knex.Transaction;
-import { normalizeArray } from '../../util/normalizeArray';
+import { getUnsupportedLocales } from '../routes/validation';
+import { User } from '../../../typings/User';
 
 export interface TemplatesGetListFilters {
     domainId?: number | 'null';
@@ -17,6 +23,25 @@ export interface TemplatesGetListFilters {
     name?: string[] | string;
 }
 
+interface UpdateTemplateResultOk {
+    type: 'ok';
+    template: VersionedRecord<TemplateWithLocalizedVersions>;
+}
+
+interface UpdateTemplateResultNotFound {
+    type: 'notFound';
+}
+
+interface UpdateTemplateResultLocalesNotSupported {
+    type: 'localeNotSupported';
+    locales: string[];
+}
+
+type UpdateTemplateResult =
+    | UpdateTemplateResultOk
+    | UpdateTemplateResultNotFound
+    | UpdateTemplateResultLocalesNotSupported;
+
 export class TemplatesRepository {
     constructor(private db: VersionedKnex) {}
 
@@ -47,11 +72,15 @@ export class TemplatesRepository {
         };
     }
 
-    async readTemplateWithAllVersions(templateName: string) {
+    async readTemplateWithAllVersions(
+        templateName: string,
+    ): Promise<VersionedRecord<TemplateWithLocalizedVersions> | undefined> {
         const { db } = this;
 
         const [template] = await db
-            .selectVersionedRowsFrom(Tables.Templates, 'name', EntityTypes.templates, [`${Tables.Templates}.*`])
+            .selectVersionedRowsFrom<Template>(Tables.Templates, 'name', EntityTypes.templates, [
+                `${Tables.Templates}.*`,
+            ])
             .where('name', templateName);
 
         if (!template) {
@@ -60,19 +89,64 @@ export class TemplatesRepository {
 
         template.versionId = appendDigest(template.versionId, 'template');
 
-        const localizedTemplates: LocalizedTemplate[] = await db
+        const localizedTemplates: LocalizedTemplateRow[] = await db
             .select()
-            .from<LocalizedTemplate>(Tables.TemplatesLocalized)
+            .from<LocalizedTemplateRow>(Tables.TemplatesLocalized)
             .where('templateName', templateName);
-        template.localizedVersions = localizedTemplates.reduce(
+
+        const localizedVersions = localizedTemplates.reduce(
             (acc, item) => {
                 acc[item.locale] = { content: item.content };
                 return acc;
             },
-            {} as Record<string, object>,
+            {} as Record<string, LocalizedVersion>,
         );
 
-        return template;
+        return { ...template, localizedVersions };
+    }
+
+    async updateTemplate(
+        templateName: string,
+        payload: UpdateTemplatePayload,
+        user: User,
+    ): Promise<UpdateTemplateResult> {
+        const { db } = this;
+
+        const template = {
+            content: payload.content,
+        };
+        const templatesToUpdate = await db(Tables.Templates).where({
+            name: templateName,
+        });
+        if (!templatesToUpdate.length) {
+            return { type: 'notFound' };
+        }
+        const localizedVersions = payload.localizedVersions ?? {};
+        const unsupportedLocales = await getUnsupportedLocales(Object.keys(localizedVersions));
+        if (unsupportedLocales.length > 0) {
+            return { type: 'localeNotSupported', locales: unsupportedLocales };
+        }
+
+        await db.versioning(
+            user,
+            {
+                type: EntityTypes.templates,
+                id: templateName,
+            },
+            async (trx) => {
+                await db(Tables.Templates).where({ name: templateName }).update(template).transacting(trx);
+                await templatesRepository.upsertLocalizedVersions(templateName, localizedVersions, trx);
+            },
+        );
+
+        const updatedTemplate = await templatesRepository.readTemplateWithAllVersions(templateName);
+        if (!updatedTemplate) {
+            // This time we cannot simply return UpdateTemplateResultNotFound result,
+            // because the template is assumed to have been just updated,
+            // so it must exist.
+            throw new Error(`Template ${templateName} not found`);
+        }
+        return { type: 'ok', template: updatedTemplate };
     }
 
     async upsertLocalizedVersions(templateName: string, localizedVersions: any, trx: Transaction) {
@@ -119,6 +193,8 @@ export class TemplatesRepository {
     }
 
     private addFilterByDomainId(query: Knex.QueryBuilder, filters: TemplatesGetListFilters) {
+        const { db } = this;
+
         if (!filters.domainId) {
             return;
         }

From 33aa8af0cec2d71dd2445788e5f73c9ccc30c1d8 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Tue, 1 Oct 2024 13:09:53 +0200
Subject: [PATCH 02/13] feat(registry): add routes to manage localized
 templates

 - `PUT /api/v1/templates/{name}/localizedVersions/{locale}` body: `{ content: string }`
 - `DELETE /api/v1/templates/{name}/localizedVersions/{locale}`
---
 .../routes/deleteTemplateLocalizedVersion.ts  | 43 +++++++++
 registry/server/templates/routes/index.ts     |  4 +
 .../routes/upsertTemplateLocalizedVersion.ts  | 61 ++++++++++++
 .../server/templates/routes/validation.ts     | 19 ++--
 .../templates/services/templatesRepository.ts | 88 +++++++++++++++++-
 registry/tests/templates.spec.ts              | 92 +++++++++++++++++++
 6 files changed, 297 insertions(+), 10 deletions(-)
 create mode 100644 registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
 create mode 100644 registry/server/templates/routes/upsertTemplateLocalizedVersion.ts

diff --git a/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts b/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
new file mode 100644
index 000000000..a6c5aac3a
--- /dev/null
+++ b/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
@@ -0,0 +1,43 @@
+import { Request, Response } from 'express';
+import Joi from 'joi';
+
+import { exhaustiveCheck } from 'ts-exhaustive-check';
+import validateRequestFactory from '../../common/services/validateRequest';
+import { templatesRepository } from '../services/templatesRepository';
+import { localeNameSchema, templateNameSchema } from './validation';
+
+const validateRequestBeforeDeleteTemplateLocalizedVersion = validateRequestFactory([
+    {
+        schema: Joi.object({
+            name: templateNameSchema.required(),
+            locale: localeNameSchema.required(),
+        }),
+        selector: 'params',
+    },
+]);
+
+type Params = {
+    name: string;
+    locale: string;
+};
+
+const deleteTemplateLocalizedVersion = async (req: Request<Params>, res: Response): Promise<void> => {
+    const { name: templateName, locale } = req.params;
+
+    const result = await templatesRepository.deleteLocalizedVersion(templateName, locale);
+    switch (result.type) {
+        case 'notFound': {
+            res.status(404).send('Not found');
+            return;
+        }
+        case 'ok': {
+            res.status(204).send();
+            return;
+        }
+        default: {
+            exhaustiveCheck(result);
+        }
+    }
+};
+
+export default [validateRequestBeforeDeleteTemplateLocalizedVersion, deleteTemplateLocalizedVersion];
diff --git a/registry/server/templates/routes/index.ts b/registry/server/templates/routes/index.ts
index d395c8e31..26cf13f25 100644
--- a/registry/server/templates/routes/index.ts
+++ b/registry/server/templates/routes/index.ts
@@ -6,6 +6,8 @@ import getTemplates from './getTemplates';
 import updateTemplate from './updateTemplate';
 import createTemplate from './createTemplate';
 import deleteTemplate from './deleteTemplate';
+import upsertTemplateLocalizedVersion from './upsertTemplateLocalizedVersion';
+import deleteTemplateLocalizedVersion from './deleteTemplateLocalizedVersion';
 
 export default (authMw: RequestHandler[]) => {
     const templatesRouter = express.Router();
@@ -16,6 +18,8 @@ export default (authMw: RequestHandler[]) => {
     templatesRouter.get('/:name', ...getTemplate);
     templatesRouter.put('/:name', authMw, ...updateTemplate);
     templatesRouter.delete('/:name', authMw, ...deleteTemplate);
+    templatesRouter.put('/:name/localizedVersions/:locale', authMw, ...upsertTemplateLocalizedVersion);
+    templatesRouter.delete('/:name/localizedVersions/:locale', authMw, ...deleteTemplateLocalizedVersion);
 
     return templatesRouter;
 };
diff --git a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
new file mode 100644
index 000000000..f23375764
--- /dev/null
+++ b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
@@ -0,0 +1,61 @@
+import { Request, Response } from 'express';
+import Joi from 'joi';
+import validateRequestFactory from '../../common/services/validateRequest';
+import {
+    localeNameSchema,
+    localizedVersionSchema,
+    templateNameSchema,
+    unsupportedLocalesToJoiError,
+} from './validation';
+import { LocalizedVersion } from '../interfaces';
+import { joiErrorToResponse } from '../../util/helpers';
+import { exhaustiveCheck } from 'ts-exhaustive-check';
+import { templatesRepository } from '../services/templatesRepository';
+
+const validateRequestBeforeUpsertLocalizedVersion = validateRequestFactory([
+    {
+        schema: Joi.object({
+            name: templateNameSchema.required(),
+            locale: localeNameSchema.required(),
+        }),
+        selector: 'params',
+    },
+    {
+        schema: localizedVersionSchema.required(),
+        selector: 'body',
+    },
+]);
+
+type Params = {
+    name: string;
+    locale: string;
+};
+
+const upsertTemplateLocalizedVersion = async (
+    req: Request<Params, any, LocalizedVersion>,
+    res: Response,
+): Promise<void> => {
+    const { name: templateName, locale } = req.params;
+    const localizedVersion = req.body;
+
+    const result = await templatesRepository.upsertLocalizedVersion(templateName, locale, localizedVersion);
+    switch (result.type) {
+        case 'notFound': {
+            res.status(404).send('Not found');
+            return;
+        }
+        case 'localeNotSupported': {
+            res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError([result.locale])));
+            return;
+        }
+        case 'ok': {
+            res.status(200).send(result.localizedVersion);
+            return;
+        }
+        default: {
+            exhaustiveCheck(result);
+        }
+    }
+};
+
+export default [validateRequestBeforeUpsertLocalizedVersion, upsertTemplateLocalizedVersion];
diff --git a/registry/server/templates/routes/validation.ts b/registry/server/templates/routes/validation.ts
index f571e97d6..92f8c2193 100644
--- a/registry/server/templates/routes/validation.ts
+++ b/registry/server/templates/routes/validation.ts
@@ -24,15 +24,16 @@ const commonTemplate = {
     versionId: Joi.string().strip(),
 };
 
-const localizedVersions = Joi.object().pattern(
-    Joi.string()
-        .regex(/[a-z]{2}-[A-Z]{2,4}/)
-        .min(5)
-        .max(7),
-    Joi.object({
-        content: commonTemplate.content.required(),
-    }),
-);
+export const localeNameSchema = Joi.string()
+    .regex(/[a-z]{2}-[A-Z]{2,4}/)
+    .min(5)
+    .max(7);
+
+export const localizedVersionSchema = Joi.object({
+    content: commonTemplate.content.required(),
+});
+
+const localizedVersions = Joi.object().pattern(localeNameSchema, localizedVersionSchema);
 
 export const partialTemplateSchema = Joi.object({
     ...commonTemplate,
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index 0692bd37a..2673c7644 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -42,6 +42,37 @@ type UpdateTemplateResult =
     | UpdateTemplateResultNotFound
     | UpdateTemplateResultLocalesNotSupported;
 
+interface UpsertTemplateLocalizedVersionResultOk {
+    type: 'ok';
+    localizedVersion: LocalizedVersion;
+}
+
+interface UpsertTemplateLocalizedVersionResultNotFound {
+    type: 'notFound';
+}
+
+interface UpsertTemplateLocalizedVersionResultLocaleNotSupported {
+    type: 'localeNotSupported';
+    locale: string;
+}
+
+type UpsertTemplateLocalizedVersionResult =
+    | UpsertTemplateLocalizedVersionResultOk
+    | UpsertTemplateLocalizedVersionResultNotFound
+    | UpsertTemplateLocalizedVersionResultLocaleNotSupported;
+
+interface DeleteTemplateLocalizedVersionResultOk {
+    type: 'ok';
+}
+
+interface DeleteTemplateLocalizedVersionResultNotFound {
+    type: 'notFound';
+}
+
+type DeleteTemplateLocalizedVersionResult =
+    | DeleteTemplateLocalizedVersionResultOk
+    | DeleteTemplateLocalizedVersionResultNotFound;
+
 export class TemplatesRepository {
     constructor(private db: VersionedKnex) {}
 
@@ -149,7 +180,62 @@ export class TemplatesRepository {
         return { type: 'ok', template: updatedTemplate };
     }
 
-    async upsertLocalizedVersions(templateName: string, localizedVersions: any, trx: Transaction) {
+    async upsertLocalizedVersion(
+        templateName: string,
+        locale: string,
+        localizedVersion: LocalizedVersion,
+    ): Promise<UpsertTemplateLocalizedVersionResult> {
+        const { db } = this;
+        // TODO: check if locale is supported
+        const unsupportedLocales = await getUnsupportedLocales([locale]);
+        if (unsupportedLocales.length > 0) {
+            return { type: 'localeNotSupported', locale: unsupportedLocales[0] };
+        }
+
+        // TODO: check if template exists
+        const result = await db.transaction(async (trx): Promise<UpsertTemplateLocalizedVersionResult> => {
+            const existingTemplate = await trx(Tables.Templates).where({ name: templateName }).select(1).first();
+            if (!existingTemplate) {
+                return { type: 'notFound' };
+            }
+
+            const existingRecord = await trx(Tables.TemplatesLocalized)
+                .where({ templateName, locale })
+                .select(1)
+                .first();
+
+            if (existingRecord) {
+                await trx(Tables.TemplatesLocalized)
+                    .update({ content: localizedVersion.content })
+                    .where({ templateName, locale });
+            } else {
+                await trx(Tables.TemplatesLocalized).insert({
+                    templateName,
+                    locale,
+                    content: localizedVersion.content,
+                });
+            }
+
+            return { type: 'ok', localizedVersion } as const;
+        });
+
+        return result;
+    }
+
+    async deleteLocalizedVersion(templateName: string, locale: string): Promise<DeleteTemplateLocalizedVersionResult> {
+        const { db } = this;
+        const result = await db(Tables.TemplatesLocalized).where({ templateName, locale }).delete();
+        if (result === 0) {
+            return { type: 'notFound' };
+        }
+        return { type: 'ok' };
+    }
+
+    private async upsertLocalizedVersions(
+        templateName: string,
+        localizedVersions: Record<string, LocalizedVersion>,
+        trx: Transaction,
+    ): Promise<void> {
         const { db } = this;
 
         const locales = Object.keys(localizedVersions);
diff --git a/registry/tests/templates.spec.ts b/registry/tests/templates.spec.ts
index 05df87c9a..d1c59feed 100644
--- a/registry/tests/templates.spec.ts
+++ b/registry/tests/templates.spec.ts
@@ -771,4 +771,96 @@ describe(`Tests ${example.url}`, () => {
             }
         });
     });
+
+    describe.only('Localized', () => {
+        describe('Create', () => {
+            it('should not allow to create localized template version for unsupported locale', async () => {
+                try {
+                    await req.post(example.url).send(example.correct).expect(200);
+
+                    await req
+                        .put(example.url + example.correct.name + '/localizedVersions/pt-BR')
+                        .send({ content: example.correct.content })
+                        .expect(422);
+                } finally {
+                    await req.delete(example.url + example.correct.name).expect(204);
+                }
+            });
+            it('should not allow to create localized template version for a non-existent template', async () => {
+                const nonExistentTemplate = 'non-existent-template';
+
+                await req
+                    .put(example.url + nonExistentTemplate + '/localizedVersions/ua-UA')
+                    .send({ content: example.correct.content })
+                    .expect(404);
+            });
+            it('should create localized template version', async () => {
+                try {
+                    await req.post(example.url).send(example.correct).expect(200);
+
+                    await req
+                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .send({ content: example.correct.content })
+                        .expect(200);
+                } finally {
+                    await req.delete(example.url + example.correct.name).expect(204);
+                }
+            });
+        });
+
+        describe('Update', () => {
+            it('should update localized template version', async () => {
+                try {
+                    await req.post(example.url).send(example.correct).expect(200);
+                    await req
+                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .send({ content: example.correct.content })
+                        .expect(200);
+                    await req
+                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .send({ content: example.updated.content })
+                        .expect(200);
+                } finally {
+                    await req.delete(example.url + example.correct.name).expect(204);
+                }
+            });
+        });
+
+        describe.only('Delete', () => {
+            it('should not allow to delete localized template version for a non-existent template', async () => {
+                const nonExistentTemplate = 'non-existent-template';
+
+                await req
+                    .put(example.url + nonExistentTemplate + '/localizedVersions/ua-UA')
+                    .send({ content: example.correct.content })
+                    .expect(404);
+            });
+
+            it('should not allow to delete a non-existent localized template version', async () => {
+                try {
+                    await req.post(example.url).send(example.correct).expect(200);
+                    await req
+                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .send({ content: example.correct.content })
+                        .expect(200);
+                    await req.delete(example.url + example.correct.name + '/localizedVersions/en-US').expect(404);
+                } finally {
+                    await req.delete(example.url + example.correct.name).expect(204);
+                }
+            });
+
+            it('should delete localized template version', async () => {
+                try {
+                    await req.post(example.url).send(example.correct).expect(200);
+                    await req
+                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .send({ content: example.correct.content })
+                        .expect(200);
+                    await req.delete(example.url + example.correct.name + '/localizedVersions/ua-UA').expect(204);
+                } finally {
+                    await req.delete(example.url + example.correct.name).expect(204);
+                }
+            });
+        });
+    });
 });

From 027684679798ec5156db7e6be92cae87394ed6e9 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Tue, 1 Oct 2024 13:20:08 +0200
Subject: [PATCH 03/13] fix(regitsry/tests): remove `.only`

---
 registry/tests/templates.spec.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/registry/tests/templates.spec.ts b/registry/tests/templates.spec.ts
index d1c59feed..0dd87ce9f 100644
--- a/registry/tests/templates.spec.ts
+++ b/registry/tests/templates.spec.ts
@@ -772,7 +772,7 @@ describe(`Tests ${example.url}`, () => {
         });
     });
 
-    describe.only('Localized', () => {
+    describe('Localized', () => {
         describe('Create', () => {
             it('should not allow to create localized template version for unsupported locale', async () => {
                 try {
@@ -826,7 +826,7 @@ describe(`Tests ${example.url}`, () => {
             });
         });
 
-        describe.only('Delete', () => {
+        describe('Delete', () => {
             it('should not allow to delete localized template version for a non-existent template', async () => {
                 const nonExistentTemplate = 'non-existent-template';
 

From 118b8524e62ad584c0ce6bbdcd397f672b9cb884 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Tue, 1 Oct 2024 13:50:02 +0200
Subject: [PATCH 04/13] refactor(registry): move createTemplate logic to the
 repository

---
 registry/server/templates/interfaces/index.ts |  3 +
 .../server/templates/routes/createTemplate.ts | 55 ++++++-------------
 .../server/templates/routes/validation.ts     | 19 +------
 .../templates/services/templatesRepository.ts | 51 +++++++++++++++++
 4 files changed, 73 insertions(+), 55 deletions(-)

diff --git a/registry/server/templates/interfaces/index.ts b/registry/server/templates/interfaces/index.ts
index cf0f84a90..ea64fc167 100644
--- a/registry/server/templates/interfaces/index.ts
+++ b/registry/server/templates/interfaces/index.ts
@@ -19,3 +19,6 @@ export interface TemplateWithLocalizedVersions extends Template {
 
 export type UpdateTemplatePayload = Omit<Template, 'name' | 'localizedVersions'> &
     Partial<Pick<TemplateWithLocalizedVersions, 'localizedVersions'>>;
+
+export type CreateTemplatePayload = Omit<Template, 'localizedVersions'> &
+    Partial<Pick<TemplateWithLocalizedVersions, 'localizedVersions'>>;
diff --git a/registry/server/templates/routes/createTemplate.ts b/registry/server/templates/routes/createTemplate.ts
index 82cce0be6..a8e814d44 100644
--- a/registry/server/templates/routes/createTemplate.ts
+++ b/registry/server/templates/routes/createTemplate.ts
@@ -1,11 +1,10 @@
 import { Request, Response } from 'express';
+import { exhaustiveCheck } from 'ts-exhaustive-check';
 
-import db from '../../db';
 import validateRequestFactory from '../../common/services/validateRequest';
-import Template, { LocalizedTemplateRow } from '../interfaces';
-import { Tables } from '../../db/structure';
+import { joiErrorToResponse } from '../../util/helpers';
 import { templatesRepository } from '../services/templatesRepository';
-import { templateSchema, validateLocalesAreSupported } from './validation';
+import { templateSchema, unsupportedLocalesToJoiError } from './validation';
 
 const validateRequestBeforeCreateTemplate = validateRequestFactory([
     {
@@ -16,45 +15,23 @@ const validateRequestBeforeCreateTemplate = validateRequestFactory([
 
 const createTemplate = async (req: Request, res: Response): Promise<void> => {
     try {
-        const request = req.body;
-        const template: Template = {
-            name: request.name,
-            content: request.content,
-        };
-
-        const locales = Object.keys(request.localizedVersions || {});
-        let localesAreValid = await validateLocalesAreSupported(locales, res);
-        if (!localesAreValid) {
-            return;
-        }
-
-        await db.versioning(req.user, { type: 'templates', id: template.name }, async (trx) => {
-            await db('templates').insert(template).transacting(trx);
-        });
-
-        if (locales.length > 0) {
-            await insertLocalizedVersions(locales, template, request);
+        const result = await templatesRepository.createTemplate(req.body, req.user!);
+        switch (result.type) {
+            case 'localeNotSupported': {
+                res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError(result.locales)));
+                return;
+            }
+            case 'ok': {
+                res.status(200).send(result.template);
+                return;
+            }
+            default: {
+                exhaustiveCheck(result);
+            }
         }
-
-        const savedTemplate = await templatesRepository.readTemplateWithAllVersions(template.name);
-        res.status(200).send(savedTemplate);
     } catch (e) {
         res.status(500).send(JSON.stringify(e));
     }
 };
 
-function insertLocalizedVersions(locales: string[], template: Template, request: Record<string, any>) {
-    return Promise.all(
-        locales.map((locale) => {
-            const localizedTemplate: LocalizedTemplateRow = {
-                templateName: template.name,
-                content: request.localizedVersions[locale].content,
-                locale: locale,
-            };
-
-            return db(Tables.TemplatesLocalized).insert(localizedTemplate);
-        }),
-    );
-}
-
 export default [validateRequestBeforeCreateTemplate, createTemplate];
diff --git a/registry/server/templates/routes/validation.ts b/registry/server/templates/routes/validation.ts
index 92f8c2193..ad20a4212 100644
--- a/registry/server/templates/routes/validation.ts
+++ b/registry/server/templates/routes/validation.ts
@@ -1,9 +1,8 @@
 import Joi from 'joi';
-import renderTemplate from '../services/renderTemplate';
-import { getJoiErr, joiErrorToResponse } from '../../util/helpers';
-import { Response } from 'express';
-import settingsService from '../../settings/services/SettingsService';
 import { SettingKeys } from '../../settings/interfaces';
+import settingsService from '../../settings/services/SettingsService';
+import { getJoiErr } from '../../util/helpers';
+import renderTemplate from '../services/renderTemplate';
 
 export const templateNameSchema = Joi.string().min(1).max(50);
 
@@ -61,15 +60,3 @@ export function unsupportedLocalesToJoiError(unsupportedLocales: string[]): Joi.
         } setting.`,
     );
 }
-
-export async function validateLocalesAreSupported(locales: string[], res: Response) {
-    const unsupportedLocales = await getUnsupportedLocales(locales);
-    if (unsupportedLocales.length > 0) {
-        const joiError = unsupportedLocalesToJoiError(unsupportedLocales);
-        res.status(422);
-        res.send(joiErrorToResponse(joiError));
-        return false;
-    }
-
-    return true;
-}
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index 2673c7644..f11e88994 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -7,6 +7,7 @@ import { appendDigest } from '../../util/hmac';
 import { normalizeArray } from '../../util/normalizeArray';
 import { EntityTypes, VersionedRecord } from '../../versioning/interfaces';
 import Template, {
+    CreateTemplatePayload,
     LocalizedTemplateRow,
     LocalizedVersion,
     TemplateWithLocalizedVersions,
@@ -23,6 +24,22 @@ export interface TemplatesGetListFilters {
     name?: string[] | string;
 }
 
+//----
+
+interface CreateTemplateResultOk {
+    type: 'ok';
+    template: VersionedRecord<TemplateWithLocalizedVersions>;
+}
+
+interface CreateTemplateResultLocalesNotSupported {
+    type: 'localeNotSupported';
+    locales: string[];
+}
+
+type CreateTemplateResult = CreateTemplateResultOk | CreateTemplateResultLocalesNotSupported;
+
+//----
+
 interface UpdateTemplateResultOk {
     type: 'ok';
     template: VersionedRecord<TemplateWithLocalizedVersions>;
@@ -42,6 +59,8 @@ type UpdateTemplateResult =
     | UpdateTemplateResultNotFound
     | UpdateTemplateResultLocalesNotSupported;
 
+//----
+
 interface UpsertTemplateLocalizedVersionResultOk {
     type: 'ok';
     localizedVersion: LocalizedVersion;
@@ -61,6 +80,8 @@ type UpsertTemplateLocalizedVersionResult =
     | UpsertTemplateLocalizedVersionResultNotFound
     | UpsertTemplateLocalizedVersionResultLocaleNotSupported;
 
+//----
+
 interface DeleteTemplateLocalizedVersionResultOk {
     type: 'ok';
 }
@@ -73,6 +94,8 @@ type DeleteTemplateLocalizedVersionResult =
     | DeleteTemplateLocalizedVersionResultOk
     | DeleteTemplateLocalizedVersionResultNotFound;
 
+//----
+
 export class TemplatesRepository {
     constructor(private db: VersionedKnex) {}
 
@@ -136,6 +159,34 @@ export class TemplatesRepository {
         return { ...template, localizedVersions };
     }
 
+    async createTemplate(template: CreateTemplatePayload, user: User): Promise<CreateTemplateResult> {
+        const { db } = this;
+        const templateToCreate = {
+            name: template.name,
+            content: template.content,
+        };
+
+        const localizedVersions = template.localizedVersions ?? {};
+        const unsupportedLocales = await getUnsupportedLocales(Object.keys(localizedVersions));
+        if (unsupportedLocales.length > 0) {
+            return { type: 'localeNotSupported', locales: unsupportedLocales };
+        }
+
+        await db.versioning(user, { type: EntityTypes.templates, id: template.name }, async (trx) => {
+            await db(Tables.Templates).insert(templateToCreate).transacting(trx);
+            if (Object.keys(localizedVersions).length > 0) {
+                await templatesRepository.upsertLocalizedVersions(template.name, localizedVersions, trx);
+            }
+        });
+
+        const savedTemplate = await templatesRepository.readTemplateWithAllVersions(template.name);
+        if (!savedTemplate) {
+            throw new Error('Failed to create template');
+        }
+
+        return { type: 'ok', template: savedTemplate };
+    }
+
     async updateTemplate(
         templateName: string,
         payload: UpdateTemplatePayload,

From 52069899dfe496f5f0620b20dca707beb326d81f Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 13:02:16 +0200
Subject: [PATCH 05/13] fix(registry): CR

---
 registry/server/templates/routes/index.ts     |  4 +-
 .../templates/services/templatesRepository.ts | 46 ++++++++-----------
 registry/tests/templates.spec.ts              | 20 ++++----
 3 files changed, 31 insertions(+), 39 deletions(-)

diff --git a/registry/server/templates/routes/index.ts b/registry/server/templates/routes/index.ts
index 26cf13f25..7fafcd26e 100644
--- a/registry/server/templates/routes/index.ts
+++ b/registry/server/templates/routes/index.ts
@@ -18,8 +18,8 @@ export default (authMw: RequestHandler[]) => {
     templatesRouter.get('/:name', ...getTemplate);
     templatesRouter.put('/:name', authMw, ...updateTemplate);
     templatesRouter.delete('/:name', authMw, ...deleteTemplate);
-    templatesRouter.put('/:name/localizedVersions/:locale', authMw, ...upsertTemplateLocalizedVersion);
-    templatesRouter.delete('/:name/localizedVersions/:locale', authMw, ...deleteTemplateLocalizedVersion);
+    templatesRouter.put('/:name/localized/:locale', authMw, ...upsertTemplateLocalizedVersion);
+    templatesRouter.delete('/:name/localized/:locale', authMw, ...deleteTemplateLocalizedVersion);
 
     return templatesRouter;
 };
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index f11e88994..2c784e33f 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -24,8 +24,6 @@ export interface TemplatesGetListFilters {
     name?: string[] | string;
 }
 
-//----
-
 interface CreateTemplateResultOk {
     type: 'ok';
     template: VersionedRecord<TemplateWithLocalizedVersions>;
@@ -38,8 +36,6 @@ interface CreateTemplateResultLocalesNotSupported {
 
 type CreateTemplateResult = CreateTemplateResultOk | CreateTemplateResultLocalesNotSupported;
 
-//----
-
 interface UpdateTemplateResultOk {
     type: 'ok';
     template: VersionedRecord<TemplateWithLocalizedVersions>;
@@ -59,8 +55,6 @@ type UpdateTemplateResult =
     | UpdateTemplateResultNotFound
     | UpdateTemplateResultLocalesNotSupported;
 
-//----
-
 interface UpsertTemplateLocalizedVersionResultOk {
     type: 'ok';
     localizedVersion: LocalizedVersion;
@@ -80,8 +74,6 @@ type UpsertTemplateLocalizedVersionResult =
     | UpsertTemplateLocalizedVersionResultNotFound
     | UpsertTemplateLocalizedVersionResultLocaleNotSupported;
 
-//----
-
 interface DeleteTemplateLocalizedVersionResultOk {
     type: 'ok';
 }
@@ -94,8 +86,6 @@ type DeleteTemplateLocalizedVersionResult =
     | DeleteTemplateLocalizedVersionResultOk
     | DeleteTemplateLocalizedVersionResultNotFound;
 
-//----
-
 export class TemplatesRepository {
     constructor(private db: VersionedKnex) {}
 
@@ -175,14 +165,11 @@ export class TemplatesRepository {
         await db.versioning(user, { type: EntityTypes.templates, id: template.name }, async (trx) => {
             await db(Tables.Templates).insert(templateToCreate).transacting(trx);
             if (Object.keys(localizedVersions).length > 0) {
-                await templatesRepository.upsertLocalizedVersions(template.name, localizedVersions, trx);
+                await this.upsertLocalizedVersions(template.name, localizedVersions, trx);
             }
         });
 
-        const savedTemplate = await templatesRepository.readTemplateWithAllVersions(template.name);
-        if (!savedTemplate) {
-            throw new Error('Failed to create template');
-        }
+        const savedTemplate = await this.mustReadTemplateWithAllVersions(template.name);
 
         return { type: 'ok', template: savedTemplate };
     }
@@ -194,9 +181,6 @@ export class TemplatesRepository {
     ): Promise<UpdateTemplateResult> {
         const { db } = this;
 
-        const template = {
-            content: payload.content,
-        };
         const templatesToUpdate = await db(Tables.Templates).where({
             name: templateName,
         });
@@ -216,18 +200,16 @@ export class TemplatesRepository {
                 id: templateName,
             },
             async (trx) => {
-                await db(Tables.Templates).where({ name: templateName }).update(template).transacting(trx);
-                await templatesRepository.upsertLocalizedVersions(templateName, localizedVersions, trx);
+                await db(Tables.Templates)
+                    .where({ name: templateName })
+                    .update({ content: payload.content })
+                    .transacting(trx);
+                await this.upsertLocalizedVersions(templateName, localizedVersions, trx);
             },
         );
 
-        const updatedTemplate = await templatesRepository.readTemplateWithAllVersions(templateName);
-        if (!updatedTemplate) {
-            // This time we cannot simply return UpdateTemplateResultNotFound result,
-            // because the template is assumed to have been just updated,
-            // so it must exist.
-            throw new Error(`Template ${templateName} not found`);
-        }
+        const updatedTemplate = await this.mustReadTemplateWithAllVersions(templateName);
+
         return { type: 'ok', template: updatedTemplate };
     }
 
@@ -282,6 +264,16 @@ export class TemplatesRepository {
         return { type: 'ok' };
     }
 
+    private async mustReadTemplateWithAllVersions(
+        templateName: string,
+    ): Promise<VersionedRecord<TemplateWithLocalizedVersions>> {
+        const maybeTemplate = await this.readTemplateWithAllVersions(templateName);
+        if (!maybeTemplate) {
+            throw new Error('Template not found');
+        }
+        return maybeTemplate;
+    }
+
     private async upsertLocalizedVersions(
         templateName: string,
         localizedVersions: Record<string, LocalizedVersion>,
diff --git a/registry/tests/templates.spec.ts b/registry/tests/templates.spec.ts
index 0dd87ce9f..b8843fc88 100644
--- a/registry/tests/templates.spec.ts
+++ b/registry/tests/templates.spec.ts
@@ -779,7 +779,7 @@ describe(`Tests ${example.url}`, () => {
                     await req.post(example.url).send(example.correct).expect(200);
 
                     await req
-                        .put(example.url + example.correct.name + '/localizedVersions/pt-BR')
+                        .put(example.url + example.correct.name + '/localized/pt-BR')
                         .send({ content: example.correct.content })
                         .expect(422);
                 } finally {
@@ -790,7 +790,7 @@ describe(`Tests ${example.url}`, () => {
                 const nonExistentTemplate = 'non-existent-template';
 
                 await req
-                    .put(example.url + nonExistentTemplate + '/localizedVersions/ua-UA')
+                    .put(example.url + nonExistentTemplate + '/localized/ua-UA')
                     .send({ content: example.correct.content })
                     .expect(404);
             });
@@ -799,7 +799,7 @@ describe(`Tests ${example.url}`, () => {
                     await req.post(example.url).send(example.correct).expect(200);
 
                     await req
-                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.correct.content })
                         .expect(200);
                 } finally {
@@ -813,11 +813,11 @@ describe(`Tests ${example.url}`, () => {
                 try {
                     await req.post(example.url).send(example.correct).expect(200);
                     await req
-                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.correct.content })
                         .expect(200);
                     await req
-                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.updated.content })
                         .expect(200);
                 } finally {
@@ -831,7 +831,7 @@ describe(`Tests ${example.url}`, () => {
                 const nonExistentTemplate = 'non-existent-template';
 
                 await req
-                    .put(example.url + nonExistentTemplate + '/localizedVersions/ua-UA')
+                    .put(example.url + nonExistentTemplate + '/localized/ua-UA')
                     .send({ content: example.correct.content })
                     .expect(404);
             });
@@ -840,10 +840,10 @@ describe(`Tests ${example.url}`, () => {
                 try {
                     await req.post(example.url).send(example.correct).expect(200);
                     await req
-                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.correct.content })
                         .expect(200);
-                    await req.delete(example.url + example.correct.name + '/localizedVersions/en-US').expect(404);
+                    await req.delete(example.url + example.correct.name + '/localized/en-US').expect(404);
                 } finally {
                     await req.delete(example.url + example.correct.name).expect(204);
                 }
@@ -853,10 +853,10 @@ describe(`Tests ${example.url}`, () => {
                 try {
                     await req.post(example.url).send(example.correct).expect(200);
                     await req
-                        .put(example.url + example.correct.name + '/localizedVersions/ua-UA')
+                        .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.correct.content })
                         .expect(200);
-                    await req.delete(example.url + example.correct.name + '/localizedVersions/ua-UA').expect(204);
+                    await req.delete(example.url + example.correct.name + '/localized/ua-UA').expect(204);
                 } finally {
                     await req.delete(example.url + example.correct.name).expect(204);
                 }

From 64f03b2ac6009496e72fbc41e537b8c0f50fe34f Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 13:08:16 +0200
Subject: [PATCH 06/13] fix(registry): CR - remove ts-exhaustive-check

---
 registry/package-lock.json                               | 7 -------
 registry/package.json                                    | 3 +--
 registry/server/templates/routes/createTemplate.ts       | 2 +-
 .../templates/routes/deleteTemplateLocalizedVersion.ts   | 2 +-
 registry/server/templates/routes/updateTemplate.ts       | 2 +-
 .../templates/routes/upsertTemplateLocalizedVersion.ts   | 9 +++++----
 registry/server/util/exhaustiveCheck.ts                  | 3 +++
 7 files changed, 12 insertions(+), 16 deletions(-)
 create mode 100644 registry/server/util/exhaustiveCheck.ts

diff --git a/registry/package-lock.json b/registry/package-lock.json
index 6335803e1..121fe76c1 100644
--- a/registry/package-lock.json
+++ b/registry/package-lock.json
@@ -39,7 +39,6 @@
                 "serve-static": "^1.16.2",
                 "source-map-support": "^0.5.21",
                 "sqlite3": "^5.1.7",
-                "ts-exhaustive-check": "^1.0.0",
                 "url-join": "^4.0.1",
                 "uuid": "^9.0.1"
             },
@@ -8557,12 +8556,6 @@
                 "node": ">= 14.0.0"
             }
         },
-        "node_modules/ts-exhaustive-check": {
-            "version": "1.0.0",
-            "resolved": "https://registry.npmjs.org/ts-exhaustive-check/-/ts-exhaustive-check-1.0.0.tgz",
-            "integrity": "sha512-sKNyrdJfB1nsPMip5+xSKPdwuZ8XZ1WgxGw3ho4qXGlUQ4BGmmS0voGBK0ecimcvqzhVk84RF4JOhtZEIJWiNw==",
-            "license": "MIT"
-        },
         "node_modules/ts-node": {
             "version": "10.9.2",
             "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
diff --git a/registry/package.json b/registry/package.json
index 0cfa5efde..527feab44 100644
--- a/registry/package.json
+++ b/registry/package.json
@@ -95,7 +95,6 @@
         "serve-static": "^1.16.2",
         "source-map-support": "^0.5.21",
         "sqlite3": "^5.1.7",
-        "ts-exhaustive-check": "^1.0.0",
         "url-join": "^4.0.1",
         "uuid": "^9.0.1"
     },
@@ -103,4 +102,4 @@
         "node": "^20.8.0"
     },
     "engineStrict": true
-}
+}
\ No newline at end of file
diff --git a/registry/server/templates/routes/createTemplate.ts b/registry/server/templates/routes/createTemplate.ts
index a8e814d44..f55fc1435 100644
--- a/registry/server/templates/routes/createTemplate.ts
+++ b/registry/server/templates/routes/createTemplate.ts
@@ -1,7 +1,7 @@
 import { Request, Response } from 'express';
-import { exhaustiveCheck } from 'ts-exhaustive-check';
 
 import validateRequestFactory from '../../common/services/validateRequest';
+import { exhaustiveCheck } from '../../util/exhaustiveCheck';
 import { joiErrorToResponse } from '../../util/helpers';
 import { templatesRepository } from '../services/templatesRepository';
 import { templateSchema, unsupportedLocalesToJoiError } from './validation';
diff --git a/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts b/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
index a6c5aac3a..c85f75248 100644
--- a/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
+++ b/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
@@ -1,8 +1,8 @@
 import { Request, Response } from 'express';
 import Joi from 'joi';
 
-import { exhaustiveCheck } from 'ts-exhaustive-check';
 import validateRequestFactory from '../../common/services/validateRequest';
+import { exhaustiveCheck } from '../../util/exhaustiveCheck';
 import { templatesRepository } from '../services/templatesRepository';
 import { localeNameSchema, templateNameSchema } from './validation';
 
diff --git a/registry/server/templates/routes/updateTemplate.ts b/registry/server/templates/routes/updateTemplate.ts
index fe0deaa9c..8d41581c3 100644
--- a/registry/server/templates/routes/updateTemplate.ts
+++ b/registry/server/templates/routes/updateTemplate.ts
@@ -1,8 +1,8 @@
 import { Request, Response } from 'express';
 import Joi from 'joi';
-import { exhaustiveCheck } from 'ts-exhaustive-check';
 
 import validateRequestFactory from '../../common/services/validateRequest';
+import { exhaustiveCheck } from '../../util/exhaustiveCheck';
 import { joiErrorToResponse } from '../../util/helpers';
 import { templatesRepository } from '../services/templatesRepository';
 import { partialTemplateSchema, templateNameSchema, unsupportedLocalesToJoiError } from './validation';
diff --git a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
index f23375764..b77522628 100644
--- a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
+++ b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
@@ -1,16 +1,17 @@
 import { Request, Response } from 'express';
 import Joi from 'joi';
+
 import validateRequestFactory from '../../common/services/validateRequest';
+import { exhaustiveCheck } from '../../util/exhaustiveCheck';
+import { joiErrorToResponse } from '../../util/helpers';
+import { LocalizedVersion } from '../interfaces';
+import { templatesRepository } from '../services/templatesRepository';
 import {
     localeNameSchema,
     localizedVersionSchema,
     templateNameSchema,
     unsupportedLocalesToJoiError,
 } from './validation';
-import { LocalizedVersion } from '../interfaces';
-import { joiErrorToResponse } from '../../util/helpers';
-import { exhaustiveCheck } from 'ts-exhaustive-check';
-import { templatesRepository } from '../services/templatesRepository';
 
 const validateRequestBeforeUpsertLocalizedVersion = validateRequestFactory([
     {
diff --git a/registry/server/util/exhaustiveCheck.ts b/registry/server/util/exhaustiveCheck.ts
new file mode 100644
index 000000000..24439583c
--- /dev/null
+++ b/registry/server/util/exhaustiveCheck.ts
@@ -0,0 +1,3 @@
+export function exhaustiveCheck(value: never): never {
+    throw new Error(`Unexpected value: ${value}`);
+}

From 9a8b21a8b1e5a4e1a9ea2afc010c1c624139757e Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 13:21:46 +0200
Subject: [PATCH 07/13] fix(registry): CR - do an explicit assert on `req.user`
 instead of TS non-null assertion operator (`!`)

---
 registry/server/templates/routes/createTemplate.ts | 4 +++-
 registry/server/templates/routes/updateTemplate.ts | 9 +++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/registry/server/templates/routes/createTemplate.ts b/registry/server/templates/routes/createTemplate.ts
index f55fc1435..179e17673 100644
--- a/registry/server/templates/routes/createTemplate.ts
+++ b/registry/server/templates/routes/createTemplate.ts
@@ -1,3 +1,4 @@
+import { ok } from 'assert';
 import { Request, Response } from 'express';
 
 import validateRequestFactory from '../../common/services/validateRequest';
@@ -15,7 +16,8 @@ const validateRequestBeforeCreateTemplate = validateRequestFactory([
 
 const createTemplate = async (req: Request, res: Response): Promise<void> => {
     try {
-        const result = await templatesRepository.createTemplate(req.body, req.user!);
+        ok(req.user);
+        const result = await templatesRepository.createTemplate(req.body, req.user);
         switch (result.type) {
             case 'localeNotSupported': {
                 res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError(result.locales)));
diff --git a/registry/server/templates/routes/updateTemplate.ts b/registry/server/templates/routes/updateTemplate.ts
index 8d41581c3..e2fe7851b 100644
--- a/registry/server/templates/routes/updateTemplate.ts
+++ b/registry/server/templates/routes/updateTemplate.ts
@@ -1,3 +1,4 @@
+import { ok } from 'assert';
 import { Request, Response } from 'express';
 import Joi from 'joi';
 
@@ -25,12 +26,8 @@ const validateRequestBeforeUpdateTemplate = validateRequestFactory([
 ]);
 
 const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Response): Promise<void> => {
-    const result = await templatesRepository.updateTemplate(
-        req.params.name,
-        req.body,
-        // TODO: cheeck if user here is really required
-        req.user!,
-    );
+    ok(req.user);
+    const result = await templatesRepository.updateTemplate(req.params.name, req.body, req.user);
 
     switch (result.type) {
         case 'notFound': {

From b2e2b57593c7093d208fcefde52ae6d460a8007d Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 13:36:11 +0200
Subject: [PATCH 08/13] fix(registry): CR - remove the assert over req.user,
 because it is allowed to be undefined (in the tests); add missing expects in
 the tests

---
 .../server/templates/routes/createTemplate.ts     |  2 --
 .../server/templates/routes/updateTemplate.ts     |  2 --
 .../templates/services/templatesRepository.ts     | 10 ++++------
 registry/tests/templates.spec.ts                  | 15 ++++++++++++---
 4 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/registry/server/templates/routes/createTemplate.ts b/registry/server/templates/routes/createTemplate.ts
index 179e17673..e03b88fb4 100644
--- a/registry/server/templates/routes/createTemplate.ts
+++ b/registry/server/templates/routes/createTemplate.ts
@@ -1,4 +1,3 @@
-import { ok } from 'assert';
 import { Request, Response } from 'express';
 
 import validateRequestFactory from '../../common/services/validateRequest';
@@ -16,7 +15,6 @@ const validateRequestBeforeCreateTemplate = validateRequestFactory([
 
 const createTemplate = async (req: Request, res: Response): Promise<void> => {
     try {
-        ok(req.user);
         const result = await templatesRepository.createTemplate(req.body, req.user);
         switch (result.type) {
             case 'localeNotSupported': {
diff --git a/registry/server/templates/routes/updateTemplate.ts b/registry/server/templates/routes/updateTemplate.ts
index e2fe7851b..7433bb764 100644
--- a/registry/server/templates/routes/updateTemplate.ts
+++ b/registry/server/templates/routes/updateTemplate.ts
@@ -1,4 +1,3 @@
-import { ok } from 'assert';
 import { Request, Response } from 'express';
 import Joi from 'joi';
 
@@ -26,7 +25,6 @@ const validateRequestBeforeUpdateTemplate = validateRequestFactory([
 ]);
 
 const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Response): Promise<void> => {
-    ok(req.user);
     const result = await templatesRepository.updateTemplate(req.params.name, req.body, req.user);
 
     switch (result.type) {
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index 2c784e33f..0d8a40841 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -1,6 +1,7 @@
 import { Knex } from 'knex';
 
 import { PaginatedResult } from '../../../typings/PaginatedResult';
+import { User } from '../../../typings/User';
 import db, { VersionedKnex } from '../../db';
 import { Tables } from '../../db/structure';
 import { appendDigest } from '../../util/hmac';
@@ -13,10 +14,9 @@ import Template, {
     TemplateWithLocalizedVersions,
     UpdateTemplatePayload,
 } from '../interfaces';
+import { getUnsupportedLocales } from '../routes/validation';
 
 import Transaction = Knex.Transaction;
-import { getUnsupportedLocales } from '../routes/validation';
-import { User } from '../../../typings/User';
 
 export interface TemplatesGetListFilters {
     domainId?: number | 'null';
@@ -149,7 +149,7 @@ export class TemplatesRepository {
         return { ...template, localizedVersions };
     }
 
-    async createTemplate(template: CreateTemplatePayload, user: User): Promise<CreateTemplateResult> {
+    async createTemplate(template: CreateTemplatePayload, user: User | undefined): Promise<CreateTemplateResult> {
         const { db } = this;
         const templateToCreate = {
             name: template.name,
@@ -177,7 +177,7 @@ export class TemplatesRepository {
     async updateTemplate(
         templateName: string,
         payload: UpdateTemplatePayload,
-        user: User,
+        user: User | undefined,
     ): Promise<UpdateTemplateResult> {
         const { db } = this;
 
@@ -219,13 +219,11 @@ export class TemplatesRepository {
         localizedVersion: LocalizedVersion,
     ): Promise<UpsertTemplateLocalizedVersionResult> {
         const { db } = this;
-        // TODO: check if locale is supported
         const unsupportedLocales = await getUnsupportedLocales([locale]);
         if (unsupportedLocales.length > 0) {
             return { type: 'localeNotSupported', locale: unsupportedLocales[0] };
         }
 
-        // TODO: check if template exists
         const result = await db.transaction(async (trx): Promise<UpsertTemplateLocalizedVersionResult> => {
             const existingTemplate = await trx(Tables.Templates).where({ name: templateName }).select(1).first();
             if (!existingTemplate) {
diff --git a/registry/tests/templates.spec.ts b/registry/tests/templates.spec.ts
index b8843fc88..d54120c46 100644
--- a/registry/tests/templates.spec.ts
+++ b/registry/tests/templates.spec.ts
@@ -786,6 +786,7 @@ describe(`Tests ${example.url}`, () => {
                     await req.delete(example.url + example.correct.name).expect(204);
                 }
             });
+
             it('should not allow to create localized template version for a non-existent template', async () => {
                 const nonExistentTemplate = 'non-existent-template';
 
@@ -794,14 +795,19 @@ describe(`Tests ${example.url}`, () => {
                     .send({ content: example.correct.content })
                     .expect(404);
             });
-            it('should create localized template version', async () => {
+
+            it.only('should create localized template version', async () => {
                 try {
                     await req.post(example.url).send(example.correct).expect(200);
 
-                    await req
+                    const response = await req
                         .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.correct.content })
                         .expect(200);
+
+                    expect(response.body).deep.equal({
+                        content: example.correct.content,
+                    });
                 } finally {
                     await req.delete(example.url + example.correct.name).expect(204);
                 }
@@ -816,10 +822,13 @@ describe(`Tests ${example.url}`, () => {
                         .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.correct.content })
                         .expect(200);
-                    await req
+                    const response = await req
                         .put(example.url + example.correct.name + '/localized/ua-UA')
                         .send({ content: example.updated.content })
                         .expect(200);
+                    expect(response.body).deep.equal({
+                        content: example.updated.content,
+                    });
                 } finally {
                     await req.delete(example.url + example.correct.name).expect(204);
                 }

From a742f6c02b0d63d55a3f3fa10c66b78fc20f3e5b Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 13:47:23 +0200
Subject: [PATCH 09/13] fix: remove .only

---
 registry/tests/templates.spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/registry/tests/templates.spec.ts b/registry/tests/templates.spec.ts
index d54120c46..ec04d7c7f 100644
--- a/registry/tests/templates.spec.ts
+++ b/registry/tests/templates.spec.ts
@@ -796,7 +796,7 @@ describe(`Tests ${example.url}`, () => {
                     .expect(404);
             });
 
-            it.only('should create localized template version', async () => {
+            it('should create localized template version', async () => {
                 try {
                     await req.post(example.url).send(example.correct).expect(200);
 

From feeebfdb0c0fc10c5377ddf1d9564288a0501713 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 15:03:36 +0200
Subject: [PATCH 10/13] fix(registry): CR - implement unsupported locales
 validation MW as discussed

---
 registry/server/middleware/validatelocales.ts | 46 +++++++++++++++++
 .../server/templates/routes/createTemplate.ts | 26 ++++------
 .../server/templates/routes/updateTemplate.ts | 15 +++---
 .../routes/upsertTemplateLocalizedVersion.ts  | 20 +++-----
 .../server/templates/routes/validation.ts     | 14 ------
 .../templates/services/templatesRepository.ts | 50 +++----------------
 6 files changed, 78 insertions(+), 93 deletions(-)
 create mode 100644 registry/server/middleware/validatelocales.ts

diff --git a/registry/server/middleware/validatelocales.ts b/registry/server/middleware/validatelocales.ts
new file mode 100644
index 000000000..fc8f8bbf4
--- /dev/null
+++ b/registry/server/middleware/validatelocales.ts
@@ -0,0 +1,46 @@
+import { Request, Response } from 'express';
+import Joi from 'joi';
+
+import { SettingKeys } from '../settings/interfaces';
+import settingsService from '../settings/services/SettingsService';
+import { getJoiErr, joiErrorToResponse } from '../util/helpers';
+
+export const validateLocalesMiddleware =
+    (
+        localesFromRequest: (req: Request) => string[],
+        unsupportedLocalesToFieldName: (unsupportedLocales: string[]) => string,
+    ) =>
+    async (req: Request, res: Response, next: () => void) => {
+        const locales = localesFromRequest(req);
+
+        if (locales.length === 0) {
+            next();
+            return;
+        }
+
+        const unsupportedLocales = await getUnsupportedLocales(locales);
+        if (unsupportedLocales.length > 0) {
+            res.status(422).send(
+                joiErrorToResponse(
+                    unsupportedLocalesToJoiError(unsupportedLocales, unsupportedLocalesToFieldName(unsupportedLocales)),
+                ),
+            );
+            return;
+        }
+
+        next();
+    };
+
+async function getUnsupportedLocales(locales: string[]): Promise<string[]> {
+    const supportedLocales = await settingsService.get(SettingKeys.I18nSupportedLocales);
+    return locales.filter((l) => !supportedLocales.includes(l));
+}
+
+function unsupportedLocalesToJoiError(unsupportedLocales: string[], field: string): Joi.ValidationError {
+    return getJoiErr(
+        `localizedVersions.${unsupportedLocales[0]}`,
+        `Next locales are not supported ${unsupportedLocales.join(',')}. Either change request or change ${
+            SettingKeys.I18nSupportedLocales
+        } setting.`,
+    );
+}
diff --git a/registry/server/templates/routes/createTemplate.ts b/registry/server/templates/routes/createTemplate.ts
index e03b88fb4..2d4f3d525 100644
--- a/registry/server/templates/routes/createTemplate.ts
+++ b/registry/server/templates/routes/createTemplate.ts
@@ -1,10 +1,9 @@
 import { Request, Response } from 'express';
 
 import validateRequestFactory from '../../common/services/validateRequest';
-import { exhaustiveCheck } from '../../util/exhaustiveCheck';
-import { joiErrorToResponse } from '../../util/helpers';
 import { templatesRepository } from '../services/templatesRepository';
-import { templateSchema, unsupportedLocalesToJoiError } from './validation';
+import { templateSchema } from './validation';
+import { validateLocalesMiddleware } from '../../middleware/validatelocales';
 
 const validateRequestBeforeCreateTemplate = validateRequestFactory([
     {
@@ -13,25 +12,18 @@ const validateRequestBeforeCreateTemplate = validateRequestFactory([
     },
 ]);
 
+const validateLocale = validateLocalesMiddleware(
+    (req) => Object.keys(req.body.localizedVersions ?? {}),
+    (unsupportedLocales) => `body.localizedVersions.${unsupportedLocales[0]}`,
+);
+
 const createTemplate = async (req: Request, res: Response): Promise<void> => {
     try {
         const result = await templatesRepository.createTemplate(req.body, req.user);
-        switch (result.type) {
-            case 'localeNotSupported': {
-                res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError(result.locales)));
-                return;
-            }
-            case 'ok': {
-                res.status(200).send(result.template);
-                return;
-            }
-            default: {
-                exhaustiveCheck(result);
-            }
-        }
+        res.status(200).send(result);
     } catch (e) {
         res.status(500).send(JSON.stringify(e));
     }
 };
 
-export default [validateRequestBeforeCreateTemplate, createTemplate];
+export default [validateRequestBeforeCreateTemplate, validateLocale, createTemplate];
diff --git a/registry/server/templates/routes/updateTemplate.ts b/registry/server/templates/routes/updateTemplate.ts
index 7433bb764..817010ad9 100644
--- a/registry/server/templates/routes/updateTemplate.ts
+++ b/registry/server/templates/routes/updateTemplate.ts
@@ -2,10 +2,10 @@ import { Request, Response } from 'express';
 import Joi from 'joi';
 
 import validateRequestFactory from '../../common/services/validateRequest';
+import { validateLocalesMiddleware } from '../../middleware/validatelocales';
 import { exhaustiveCheck } from '../../util/exhaustiveCheck';
-import { joiErrorToResponse } from '../../util/helpers';
 import { templatesRepository } from '../services/templatesRepository';
-import { partialTemplateSchema, templateNameSchema, unsupportedLocalesToJoiError } from './validation';
+import { partialTemplateSchema, templateNameSchema } from './validation';
 
 type UpdateTemplateRequestParams = {
     name: string;
@@ -24,6 +24,11 @@ const validateRequestBeforeUpdateTemplate = validateRequestFactory([
     },
 ]);
 
+const validateLocale = validateLocalesMiddleware(
+    (req) => Object.keys(req.body.localizedVersions ?? {}),
+    (unsupportedLocales) => `body.localizedVersions.${unsupportedLocales[0]}`,
+);
+
 const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Response): Promise<void> => {
     const result = await templatesRepository.updateTemplate(req.params.name, req.body, req.user);
 
@@ -32,10 +37,6 @@ const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Re
             res.status(404).send('Not found');
             return;
         }
-        case 'localeNotSupported': {
-            res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError(result.locales)));
-            return;
-        }
         case 'ok': {
             res.status(200).send(result.template);
             return;
@@ -46,4 +47,4 @@ const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Re
     }
 };
 
-export default [validateRequestBeforeUpdateTemplate, updateTemplate];
+export default [validateRequestBeforeUpdateTemplate, validateLocale, updateTemplate];
diff --git a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
index b77522628..687de878d 100644
--- a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
+++ b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
@@ -2,16 +2,11 @@ import { Request, Response } from 'express';
 import Joi from 'joi';
 
 import validateRequestFactory from '../../common/services/validateRequest';
+import { validateLocalesMiddleware } from '../../middleware/validatelocales';
 import { exhaustiveCheck } from '../../util/exhaustiveCheck';
-import { joiErrorToResponse } from '../../util/helpers';
 import { LocalizedVersion } from '../interfaces';
 import { templatesRepository } from '../services/templatesRepository';
-import {
-    localeNameSchema,
-    localizedVersionSchema,
-    templateNameSchema,
-    unsupportedLocalesToJoiError,
-} from './validation';
+import { localeNameSchema, localizedVersionSchema, templateNameSchema } from './validation';
 
 const validateRequestBeforeUpsertLocalizedVersion = validateRequestFactory([
     {
@@ -27,6 +22,11 @@ const validateRequestBeforeUpsertLocalizedVersion = validateRequestFactory([
     },
 ]);
 
+const validateLocale = validateLocalesMiddleware(
+    (req) => [req.params.locale],
+    () => 'params.locale',
+);
+
 type Params = {
     name: string;
     locale: string;
@@ -45,10 +45,6 @@ const upsertTemplateLocalizedVersion = async (
             res.status(404).send('Not found');
             return;
         }
-        case 'localeNotSupported': {
-            res.status(422).send(joiErrorToResponse(unsupportedLocalesToJoiError([result.locale])));
-            return;
-        }
         case 'ok': {
             res.status(200).send(result.localizedVersion);
             return;
@@ -59,4 +55,4 @@ const upsertTemplateLocalizedVersion = async (
     }
 };
 
-export default [validateRequestBeforeUpsertLocalizedVersion, upsertTemplateLocalizedVersion];
+export default [validateRequestBeforeUpsertLocalizedVersion, validateLocale, upsertTemplateLocalizedVersion];
diff --git a/registry/server/templates/routes/validation.ts b/registry/server/templates/routes/validation.ts
index ad20a4212..cd7d9648e 100644
--- a/registry/server/templates/routes/validation.ts
+++ b/registry/server/templates/routes/validation.ts
@@ -46,17 +46,3 @@ export const templateSchema = Joi.object({
     content: commonTemplate.content.required(),
     localizedVersions,
 });
-
-export async function getUnsupportedLocales(locales: string[]): Promise<string[]> {
-    const supportedLocales = await settingsService.get(SettingKeys.I18nSupportedLocales);
-    return locales.filter((l) => !supportedLocales.includes(l));
-}
-
-export function unsupportedLocalesToJoiError(unsupportedLocales: string[]): Joi.ValidationError {
-    return getJoiErr(
-        `localizedVersions.${unsupportedLocales[0]}`,
-        `Next locales are not supported ${unsupportedLocales.join(',')}. Either change request or change ${
-            SettingKeys.I18nSupportedLocales
-        } setting.`,
-    );
-}
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index 0d8a40841..365b5d821 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -14,7 +14,6 @@ import Template, {
     TemplateWithLocalizedVersions,
     UpdateTemplatePayload,
 } from '../interfaces';
-import { getUnsupportedLocales } from '../routes/validation';
 
 import Transaction = Knex.Transaction;
 
@@ -24,18 +23,6 @@ export interface TemplatesGetListFilters {
     name?: string[] | string;
 }
 
-interface CreateTemplateResultOk {
-    type: 'ok';
-    template: VersionedRecord<TemplateWithLocalizedVersions>;
-}
-
-interface CreateTemplateResultLocalesNotSupported {
-    type: 'localeNotSupported';
-    locales: string[];
-}
-
-type CreateTemplateResult = CreateTemplateResultOk | CreateTemplateResultLocalesNotSupported;
-
 interface UpdateTemplateResultOk {
     type: 'ok';
     template: VersionedRecord<TemplateWithLocalizedVersions>;
@@ -45,15 +32,7 @@ interface UpdateTemplateResultNotFound {
     type: 'notFound';
 }
 
-interface UpdateTemplateResultLocalesNotSupported {
-    type: 'localeNotSupported';
-    locales: string[];
-}
-
-type UpdateTemplateResult =
-    | UpdateTemplateResultOk
-    | UpdateTemplateResultNotFound
-    | UpdateTemplateResultLocalesNotSupported;
+type UpdateTemplateResult = UpdateTemplateResultOk | UpdateTemplateResultNotFound;
 
 interface UpsertTemplateLocalizedVersionResultOk {
     type: 'ok';
@@ -64,15 +43,9 @@ interface UpsertTemplateLocalizedVersionResultNotFound {
     type: 'notFound';
 }
 
-interface UpsertTemplateLocalizedVersionResultLocaleNotSupported {
-    type: 'localeNotSupported';
-    locale: string;
-}
-
 type UpsertTemplateLocalizedVersionResult =
     | UpsertTemplateLocalizedVersionResultOk
-    | UpsertTemplateLocalizedVersionResultNotFound
-    | UpsertTemplateLocalizedVersionResultLocaleNotSupported;
+    | UpsertTemplateLocalizedVersionResultNotFound;
 
 interface DeleteTemplateLocalizedVersionResultOk {
     type: 'ok';
@@ -149,7 +122,10 @@ export class TemplatesRepository {
         return { ...template, localizedVersions };
     }
 
-    async createTemplate(template: CreateTemplatePayload, user: User | undefined): Promise<CreateTemplateResult> {
+    async createTemplate(
+        template: CreateTemplatePayload,
+        user: User | undefined,
+    ): Promise<VersionedRecord<TemplateWithLocalizedVersions>> {
         const { db } = this;
         const templateToCreate = {
             name: template.name,
@@ -157,10 +133,6 @@ export class TemplatesRepository {
         };
 
         const localizedVersions = template.localizedVersions ?? {};
-        const unsupportedLocales = await getUnsupportedLocales(Object.keys(localizedVersions));
-        if (unsupportedLocales.length > 0) {
-            return { type: 'localeNotSupported', locales: unsupportedLocales };
-        }
 
         await db.versioning(user, { type: EntityTypes.templates, id: template.name }, async (trx) => {
             await db(Tables.Templates).insert(templateToCreate).transacting(trx);
@@ -171,7 +143,7 @@ export class TemplatesRepository {
 
         const savedTemplate = await this.mustReadTemplateWithAllVersions(template.name);
 
-        return { type: 'ok', template: savedTemplate };
+        return savedTemplate;
     }
 
     async updateTemplate(
@@ -188,10 +160,6 @@ export class TemplatesRepository {
             return { type: 'notFound' };
         }
         const localizedVersions = payload.localizedVersions ?? {};
-        const unsupportedLocales = await getUnsupportedLocales(Object.keys(localizedVersions));
-        if (unsupportedLocales.length > 0) {
-            return { type: 'localeNotSupported', locales: unsupportedLocales };
-        }
 
         await db.versioning(
             user,
@@ -219,10 +187,6 @@ export class TemplatesRepository {
         localizedVersion: LocalizedVersion,
     ): Promise<UpsertTemplateLocalizedVersionResult> {
         const { db } = this;
-        const unsupportedLocales = await getUnsupportedLocales([locale]);
-        if (unsupportedLocales.length > 0) {
-            return { type: 'localeNotSupported', locale: unsupportedLocales[0] };
-        }
 
         const result = await db.transaction(async (trx): Promise<UpsertTemplateLocalizedVersionResult> => {
             const existingTemplate = await trx(Tables.Templates).where({ name: templateName }).select(1).first();

From 799de3643dc68605f8b4f8126fa5bbc927bfd21f Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 16:05:28 +0200
Subject: [PATCH 11/13] fix: increase tests coverage; ignore by-design
 unreachable code

---
 .../routes/deleteTemplateLocalizedVersion.ts    |  1 +
 .../server/templates/routes/updateTemplate.ts   |  1 +
 .../routes/upsertTemplateLocalizedVersion.ts    |  1 +
 registry/tests/templates.spec.ts                | 17 +++++++++++++++++
 4 files changed, 20 insertions(+)

diff --git a/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts b/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
index c85f75248..59d3cdb4b 100644
--- a/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
+++ b/registry/server/templates/routes/deleteTemplateLocalizedVersion.ts
@@ -35,6 +35,7 @@ const deleteTemplateLocalizedVersion = async (req: Request<Params>, res: Respons
             return;
         }
         default: {
+            /* istanbul ignore next */
             exhaustiveCheck(result);
         }
     }
diff --git a/registry/server/templates/routes/updateTemplate.ts b/registry/server/templates/routes/updateTemplate.ts
index 817010ad9..07ca8466e 100644
--- a/registry/server/templates/routes/updateTemplate.ts
+++ b/registry/server/templates/routes/updateTemplate.ts
@@ -42,6 +42,7 @@ const updateTemplate = async (req: Request<UpdateTemplateRequestParams>, res: Re
             return;
         }
         default: {
+            /* istanbul ignore next */
             exhaustiveCheck(result);
         }
     }
diff --git a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
index 687de878d..286765a78 100644
--- a/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
+++ b/registry/server/templates/routes/upsertTemplateLocalizedVersion.ts
@@ -50,6 +50,7 @@ const upsertTemplateLocalizedVersion = async (
             return;
         }
         default: {
+            /* istanbul ignore next */
             exhaustiveCheck(result);
         }
     }
diff --git a/registry/tests/templates.spec.ts b/registry/tests/templates.spec.ts
index ec04d7c7f..84bdace1c 100644
--- a/registry/tests/templates.spec.ts
+++ b/registry/tests/templates.spec.ts
@@ -514,6 +514,23 @@ describe(`Tests ${example.url}`, () => {
                 .expect(422, 'HTML template has invalid structure');
         });
 
+        it('should not update record with unsupported locale', async () => {
+            await req.post(example.url).send(example.correct).expect(200);
+
+            await req
+                .put(example.url + example.correct.name)
+                .send({
+                    content: example.correct.content,
+                    localizedVersions: {
+                        'zh-CN': { content: example.correct.content },
+                    },
+                })
+                .expect(
+                    422,
+                    'Next locales are not supported zh-CN. Either change request or change i18n.supported.locale setting.',
+                );
+        });
+
         it('should successfully update record', async () => {
             await req.post(example.url).send(example.correct).expect(200);
 

From 11d25f1424c55452724db2324fb3c39245a9a574 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 17:27:25 +0200
Subject: [PATCH 12/13] chore: formatting

---
 ilc/server/tailor/fragment-hooks.js                  |  4 ++--
 registry/server/settings/services/SettingsService.ts | 12 +++---------
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/ilc/server/tailor/fragment-hooks.js b/ilc/server/tailor/fragment-hooks.js
index 59638a98c..0440428e0 100644
--- a/ilc/server/tailor/fragment-hooks.js
+++ b/ilc/server/tailor/fragment-hooks.js
@@ -46,8 +46,8 @@ function insertStart(logger, stream, attributes, headers) {
                     isAsync
                         ? `<!-- Async fragments are not fully implemented yet: ${uri} -->`
                         : id
-                        ? asyncStylesLoadTemplate(uri, id)
-                        : '',
+                          ? asyncStylesLoadTemplate(uri, id)
+                          : '',
                 );
             } else if (ref.rel === 'fragment-script') {
                 bundleVersionOverrides.spaBundle = fixUri(attributes, ref.uri);
diff --git a/registry/server/settings/services/SettingsService.ts b/registry/server/settings/services/SettingsService.ts
index 9404c360d..2228bff4f 100644
--- a/registry/server/settings/services/SettingsService.ts
+++ b/registry/server/settings/services/SettingsService.ts
@@ -122,15 +122,9 @@ export class SettingsService {
             .from('settings')
             .innerJoin('settings_domain_value', 'settings.key', 'settings_domain_value.key')
             .where('settings_domain_value.domainId', domainId)
-            .select<SettingRaw[]>(
-                'settings.key',
-                'settings.default',
-                'settings.scope',
-                'settings.secret',
-                'settings.meta',
-                'settings_domain_value.value as value',
-                'settings_domain_value.domainId as domainId',
-            )
+            .select<
+                SettingRaw[]
+            >('settings.key', 'settings.default', 'settings.scope', 'settings.secret', 'settings.meta', 'settings_domain_value.value as value', 'settings_domain_value.domainId as domainId')
             .range(options.range);
 
         const parsedSettings = this.parseSettings(settings.data);

From 244213f7811b4197f921a779ed88dceef4cdcad8 Mon Sep 17 00:00:00 2001
From: Mark Harnyk <mark.harnyk@namecheap.com>
Date: Wed, 2 Oct 2024 17:27:34 +0200
Subject: [PATCH 13/13] fix(registry): CR - throw custom error

---
 registry/server/templates/errors.ts                       | 4 ++++
 registry/server/templates/services/templatesRepository.ts | 3 ++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/registry/server/templates/errors.ts b/registry/server/templates/errors.ts
index 5b2d54658..199e5015d 100644
--- a/registry/server/templates/errors.ts
+++ b/registry/server/templates/errors.ts
@@ -3,4 +3,8 @@ import errorExtender from '@namecheap/error-extender';
 export default {
     FetchIncludeError: errorExtender('FetchIncludeError', { defaultData: {} }),
     InvalidTemplateError: errorExtender('InvalidTemplateError', { defaultData: {} }),
+    TemplateNotFoundError: errorExtender('TemplateNotFoundError', {
+        defaultMessage: 'Template not found',
+        defaultData: {},
+    }),
 };
diff --git a/registry/server/templates/services/templatesRepository.ts b/registry/server/templates/services/templatesRepository.ts
index 365b5d821..40bffa89f 100644
--- a/registry/server/templates/services/templatesRepository.ts
+++ b/registry/server/templates/services/templatesRepository.ts
@@ -7,6 +7,7 @@ import { Tables } from '../../db/structure';
 import { appendDigest } from '../../util/hmac';
 import { normalizeArray } from '../../util/normalizeArray';
 import { EntityTypes, VersionedRecord } from '../../versioning/interfaces';
+import errors from '../errors';
 import Template, {
     CreateTemplatePayload,
     LocalizedTemplateRow,
@@ -231,7 +232,7 @@ export class TemplatesRepository {
     ): Promise<VersionedRecord<TemplateWithLocalizedVersions>> {
         const maybeTemplate = await this.readTemplateWithAllVersions(templateName);
         if (!maybeTemplate) {
-            throw new Error('Template not found');
+            throw new errors.TemplateNotFoundError({ data: { templateName } });
         }
         return maybeTemplate;
     }