feat(registry): add new router domain "alias" field

stas-nc · stas-nc · commit a1f2b7938677 · 2026-02-17T18:44:15.000+02:00
This field is used to safely bind routes across multiple ILC instances
Fixed typings
diff --git a/registry/client/README.md b/registry/client/README.md
@@ -7,7 +7,7 @@ $ npm install
 $ npm start
 ```
 
-And then browse to [http://localhost:8080/](http://localhost:8080/).
+And then browse to [http://localhost:4001/](http://localhost:4001/).
 
 The default credentials are:
 **root / pwd** - for admin access.
diff --git a/registry/client/src/routerDomains/Edit.js b/registry/client/src/routerDomains/Edit.js
@@ -30,6 +30,7 @@ const InputForm = ({ mode = 'edit', ...props }) => {
                 </ReferenceInput>
                 <TextInput source="canonicalDomain" label="Canonical Domain" fullWidth />
                 <TextInput source="brandId" label="Brand ID" fullWidth />
+                <TextInput source="alias" label="Alias" fullWidth />
             </FormTab>
 
             <FormTab label="Domain Props">
diff --git a/registry/client/src/routerDomains/List.js b/registry/client/src/routerDomains/List.js
@@ -34,6 +34,7 @@ const PostList = (props) => {
                     </ReferenceField>
                     <TextField source="canonicalDomain" sortable={false} emptyText="-" label="Canonical Domain" />
                     <TextField source="brandId" sortable={false} emptyText="-" label="Brand ID" />
+                    <TextField source="alias" sortable={false} emptyText="-" label="Alias" />
                     <ListActionsToolbar>
                         <EditButton />
                     </ListActionsToolbar>
diff --git a/registry/lde/oauth-server.ts b/registry/lde/oauth-server.ts
@@ -7,8 +7,8 @@ import { OAuth2Server } from 'oauth2-mock-server';
         await server.issuer.keys.generate('RS256');
 
         // Start the server
-        await server.start(8080);
-        console.log('Issuer URL:', server.issuer.url); // -> http://localhost:8080
+        await server.start(8085);
+        console.log('Issuer URL:', server.issuer.url);
 
         server.service.on('beforeTokenSigning', (token, req) => {
             token.payload.unique_name = 'root';
diff --git a/registry/package-lock.json b/registry/package-lock.json
diff --git a/registry/package.json b/registry/package.json
@@ -51,7 +51,7 @@
         "cross-env": "10.1.0",
         "jsonwebtoken": "^9.0.2",
         "mocha": "^11.7.5",
-        "nock": "^14.0.10",
+        "nock": "^14.0.11",
         "nodemon": "^3.1.11",
         "nyc": "^17.1.0",
         "oauth2-mock-server": "^8.2.0",
diff --git a/registry/server/appRoutes/interfaces/index.ts b/registry/server/appRoutes/interfaces/index.ts
@@ -57,6 +57,7 @@ export interface AppRoute {
     meta?: object | string | null;
     domainId?: number | null;
     domainIdIdxble?: number | null;
+    domainAlias?: string | null;
     namespace?: string | null;
 }
 
@@ -68,6 +69,7 @@ export type AppRouteDto = {
     templateName: string | null;
     slots: Record<string, AppRouteSlotDto>;
     domainId: number | null;
+    domainAlias: string | null;
     meta: Record<string, any>;
     versionId: string;
     namespace: string | null;
@@ -80,15 +82,20 @@ const commonAppRoute = {
     next: Joi.bool().default(false),
     templateName: templateNameSchema.allow(null).default(null),
     slots: Joi.object().pattern(commonAppRouteSlot.name, appRouteSlotSchema).default({}),
-    domainId: Joi.number().default(null),
+    domainId: Joi.number(),
+    domainAlias: Joi.string()
+        .lowercase()
+        .pattern(/^[a-z0-9-]+$/)
+        .max(64)
+        .trim(),
     meta: Joi.object().default({}),
     versionId: Joi.string().strip(),
     namespace: Joi.string().default(null),
 };
 
 export const partialAppRouteSchema = Joi.object({
     ...commonAppRoute,
-});
+}).oxor('domainId', 'domainAlias');
 
 const conditionSpecialRole = {
     is: Joi.exist(),
@@ -108,4 +115,4 @@ export const appRouteSchema = Joi.object<AppRouteDto>({
         is: Joi.exist(),
         then: Joi.forbidden(),
     }),
-});
+}).oxor('domainId', 'domainAlias');
diff --git a/registry/server/appRoutes/routes/RoutesService.ts b/registry/server/appRoutes/routes/RoutesService.ts
@@ -7,6 +7,7 @@ import { appendDigest } from '../../util/hmac';
 import { EntityTypes, VersionedRecord } from '../../versioning/interfaces';
 import { AppRoute, AppRouteDto, appRouteSchema, AppRouteSlot } from '../interfaces';
 import { prepareAppRouteSlotsToSave, prepareAppRouteToSave } from '../services/prepareAppRoute';
+import { resolveDomainAlias } from '../services/resolveDomainAlias';
 
 export type AppRouteWithSlot = VersionedRecord<AppRoute & AppRouteSlot>;
 
@@ -49,10 +50,11 @@ export class RoutesService {
      * @returns routeId
      */
     public async upsert(params: unknown, user: User, trxProvider: Knex.TransactionProvider): Promise<AppRoute> {
-        const { slots, ...appRoute } = await appRouteSchema.validateAsync(params, {
+        const { slots, ...validated } = await appRouteSchema.validateAsync(params, {
             noDefaults: false,
             externals: false,
         });
+        const appRoute = await resolveDomainAlias(validated);
 
         let savedAppRouteId: number;
         const appRouteRecord = prepareAppRouteToSave(appRoute);
diff --git a/registry/server/appRoutes/routes/createAppRoute.ts b/registry/server/appRoutes/routes/createAppRoute.ts
@@ -4,8 +4,9 @@ import validateRequestFactory from '../../common/services/validateRequest';
 import db from '../../db';
 import { extractInsertedId, handleForeignConstraintError } from '../../util/db';
 import { defined, getJoiErr, joiErrorToResponse } from '../../util/helpers';
-import { appRouteSchema } from '../interfaces';
+import { AppRouteDto, appRouteSchema } from '../interfaces';
 import { prepareAppRouteSlotsToSave, prepareAppRouteToSave } from '../services/prepareAppRoute';
+import { resolveDomainAlias } from '../services/resolveDomainAlias';
 import { transformSpecialRoutesForDB } from '../services/transformSpecialRoutes';
 import { retrieveAppRouteFromDB } from './getAppRoute';
 import { routesService } from './RoutesService';
@@ -17,13 +18,14 @@ const validateRequestBeforeCreateAppRoute = validateRequestFactory([
     },
 ]);
 
-const createAppRoute = async (req: Request, res: Response) => {
+const createAppRoute = async (req: Request<unknown, unknown, AppRouteDto>, res: Response) => {
     const { slots: appRouteSlots, ...appRouteData } = req.body;
 
-    const appRoute = transformSpecialRoutesForDB(appRouteData);
+    const domainResolved = await resolveDomainAlias(appRouteData);
+    const appRoute = transformSpecialRoutesForDB(domainResolved);
 
     if (appRouteData.specialRole) {
-        const existingRoute = await db.first().from('routes').where({
+        const existingRoute = await db('routes').first().where({
             route: appRoute.route,
             domainId: appRoute.domainId,
         });
diff --git a/registry/server/appRoutes/routes/updateAppRoute.ts b/registry/server/appRoutes/routes/updateAppRoute.ts
@@ -8,7 +8,8 @@ import {
     prepareAppRouteToRespond,
     prepareAppRouteToSave,
 } from '../services/prepareAppRoute';
-import { partialAppRouteSchema } from '../interfaces';
+import { resolveDomainAlias } from '../services/resolveDomainAlias';
+import { AppRouteDto, partialAppRouteSchema } from '../interfaces';
 import { appRouteIdSchema } from '../interfaces';
 import { transformSpecialRoutesForDB } from '../services/transformSpecialRoutes';
 import { routesService, RoutesService } from './RoutesService';
@@ -30,11 +31,12 @@ const validateRequestBeforeUpdateAppRoute = validateRequestFactory([
     },
 ]);
 
-const updateAppRoute = async (req: Request<UpdateAppRouteRequestParams>, res: Response) => {
+const updateAppRoute = async (req: Request<UpdateAppRouteRequestParams, unknown, AppRouteDto>, res: Response) => {
     const { slots: appRouteSlots, ...appRouteData } = req.body;
 
     const appRouteId = +req.params.id;
-    const appRoute = transformSpecialRoutesForDB(appRouteData);
+    const domainResolved = await resolveDomainAlias(appRouteData);
+    const appRoute = transformSpecialRoutesForDB(domainResolved);
 
     const countToUpdate = await db('routes').where('id', appRouteId);
     if (!countToUpdate.length) {
diff --git a/registry/server/appRoutes/services/resolveDomainAlias.ts b/registry/server/appRoutes/services/resolveDomainAlias.ts
@@ -0,0 +1,24 @@
+import db from '../../db';
+import { getJoiErr } from '../../util/helpers';
+
+/**
+ * If `domainAlias` is provided, resolves it to a `domainId` by looking up router_domains.
+ * Returns the route data with `domainId` set and `domainAlias` removed.
+ * Throws a Joi-style error if the alias doesn't match any router domain.
+ */
+export async function resolveDomainAlias<T extends { domainId?: number | null; domainAlias?: string | null }>(
+    appRoute: T,
+): Promise<T> {
+    const { domainAlias, domainId, ...rest } = appRoute;
+
+    if (!domainAlias) {
+        return { ...rest, domainId: domainId ?? null } as T;
+    }
+
+    const domain = await db('router_domains').first('id').where({ alias: domainAlias });
+    if (!domain) {
+        throw getJoiErr('domainAlias', `Router domain with alias "${domainAlias}" does not exist`);
+    }
+
+    return { ...rest, domainId: domain.id } as T;
+}
diff --git a/registry/server/appRoutes/services/transformSpecialRoutes.ts b/registry/server/appRoutes/services/transformSpecialRoutes.ts
@@ -1,9 +1,11 @@
-import { AppRouteDto } from '../interfaces';
 import { AppRouteWithSlot } from '../routes/RoutesService';
 
 export const SPECIAL_PREFIX = 'special:';
+
 export const isSpecialRoute = (route: string) => route.startsWith(SPECIAL_PREFIX);
+
 export const makeSpecialRoute = (specialRole: string) => `${SPECIAL_PREFIX}${specialRole}`;
+
 const getSpecialRole = (route: string) => route.replace(SPECIAL_PREFIX, '');
 
 export type ConsumerRoute = Omit<AppRouteWithSlot, 'route' | 'next'> & {
@@ -32,14 +34,18 @@ export function transformSpecialRoutesForConsumer(
     return Array.isArray(appRoutes) ? appRoutes.map(handleRoute) : handleRoute(appRoutes);
 }
 
-export function transformSpecialRoutesForDB({ specialRole, ...appRouteData }: AppRouteDto): AppRouteDto {
+export function transformSpecialRoutesForDB<
+    T extends { specialRole?: string; orderPos?: number | null; route?: string },
+>(appRoute: T): T {
+    const { specialRole, ...rest } = appRoute;
+
     if (!specialRole) {
-        return appRouteData;
+        return rest as T;
     }
 
     return {
-        ...appRouteData,
+        ...rest,
         orderPos: null,
         route: makeSpecialRoute(specialRole),
-    };
+    } as T;
 }
diff --git a/registry/server/errorHandler/index.ts b/registry/server/errorHandler/index.ts
@@ -1,15 +1,22 @@
 import { v4 as uuidv4 } from 'uuid';
 import { Request, Response, NextFunction } from 'express';
+import Joi from 'joi';
 import * as httpErrors from './httpErrors';
 
 import noticeError from './noticeError';
+import { joiErrorToResponse } from '../util/helpers';
 
 async function errorHandler(error: Error, req: Request, res: Response, next: NextFunction): Promise<void> {
     if (error instanceof httpErrors.NotFoundError) {
         res.status(404).send('Not found');
         return;
     }
 
+    if (error instanceof Joi.ValidationError) {
+        res.status(422).send(joiErrorToResponse(error));
+        return;
+    }
+
     if (error instanceof httpErrors.UnprocessableContent) {
         res.status(422).send(error.message);
         return;
diff --git a/registry/server/migrations/20201013140633_settings_default.ts b/registry/server/migrations/20201013140633_settings_default.ts
@@ -50,7 +50,7 @@ export async function up(knex: Knex): Promise<any> {
         },
         {
             key: SettingKeys.AuthOpenIdDiscoveryUrl,
-            value: 'http://localhost:8080',
+            value: 'http://localhost:8085',
             default: '',
             scope: Scope.Registry,
             secret: false,
diff --git a/registry/server/migrations/20260216120000_add_alias_to_router_domains.ts b/registry/server/migrations/20260216120000_add_alias_to_router_domains.ts
@@ -0,0 +1,13 @@
+import type { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+    return knex.schema.alterTable('router_domains', (table) => {
+        table.string('alias', 64).nullable().comment('Optional short code name alias for the router domain.');
+    });
+}
+
+export async function down(knex: Knex): Promise<void> {
+    return knex.schema.alterTable('router_domains', (table) => {
+        table.dropColumn('alias');
+    });
+}
diff --git a/registry/server/routerDomains/interfaces/index.ts b/registry/server/routerDomains/interfaces/index.ts
@@ -8,8 +8,9 @@ export default interface RouterDomains {
     template500?: string;
     canonicalDomain?: string | null;
     brandId?: string | null;
-    props?: Record<string, any> | null;
-    ssrProps?: Record<string, any> | null;
+    alias?: string | null;
+    props?: Record<string, unknown> | string | null;
+    ssrProps?: Record<string, unknown> | string | null;
 }
 
 export const routerDomainIdSchema = Joi.string().trim().required();
@@ -33,6 +34,13 @@ const commonRouterDomainsSchema = {
         .trim()
         .allow(null)
         .default(null),
+    alias: Joi.string()
+        .lowercase()
+        .pattern(/^[a-z0-9-]+$/)
+        .max(64)
+        .trim()
+        .allow(null)
+        .default(null),
     props: Joi.object().allow(null).default(null),
     ssrProps: Joi.object().allow(null).default(null),
     versionId: Joi.string().strip(),
diff --git a/registry/server/routerDomains/routes/createRouterDomains.ts b/registry/server/routerDomains/routes/createRouterDomains.ts
@@ -15,7 +15,10 @@ const validateRequest = validateRequestFactory([
     },
 ]);
 
-const createRouterDomains = async (req: Request, res: Response): Promise<void> => {
+const createRouterDomains = async (
+    req: Request<unknown, unknown, Omit<RouterDomains, 'id'>>,
+    res: Response,
+): Promise<void> => {
     let routerDomainId: number | undefined;
     await db.versioning(req.user, { type: 'router_domains' }, async (trx) => {
         const result = await db('router_domains')
diff --git a/registry/server/routerDomains/routes/updateRouterDomains.ts b/registry/server/routerDomains/routes/updateRouterDomains.ts
@@ -24,25 +24,26 @@ const validateRequest = validateRequestFactory([
     },
 ]);
 
-const updateRouterDomains = async (req: Request<RequestParams>, res: Response): Promise<void> => {
+const updateRouterDomains = async (
+    req: Request<RequestParams, unknown, Partial<RouterDomains>>,
+    res: Response,
+): Promise<void> => {
     const routerDomainId = req.params.id;
 
-    const countToUpdate = await db('router_domains').where({
-        id: routerDomainId,
-    });
+    const countToUpdate = await db('router_domains').where('id', routerDomainId);
     if (!countToUpdate.length) {
         res.status(404).send('Not found');
         return;
     }
 
     await db.versioning(req.user, { type: 'router_domains', id: routerDomainId }, async (trx) => {
         await db('router_domains')
-            .where({ id: routerDomainId })
+            .where('id', routerDomainId)
             .update(stringifyJSON(['props', 'ssrProps'], req.body))
             .transacting(trx);
     });
 
-    const [updatedRouterDomains] = await db.select().from<RouterDomains>('router_domains').where('id', routerDomainId);
+    const [updatedRouterDomains] = await db('router_domains').select().where('id', routerDomainId);
 
     res.status(200).send(preProcessResponse(updatedRouterDomains));
 };
diff --git a/registry/tests/appRoutes.spec.ts b/registry/tests/appRoutes.spec.ts
diff --git a/registry/tests/config.spec.ts b/registry/tests/config.spec.ts
diff --git a/registry/tests/routerDomains.spec.ts b/registry/tests/routerDomains.spec.ts
diff --git a/registry/typings/knex/tables.d.ts b/registry/typings/knex/tables.d.ts
