@privateaim/server-core-worker-kit 0.7.17

package/src/components/master-images/service/module.ts

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import type { Cache, QueueRouter, QueueRouterHandlers } from '@privateaim/server-kit';
+import { buildQueueRouterPublishPayload, useCache, useQueueRouter } from '@privateaim/server-kit';
+import { cleanupPayload } from '../../../utils';
+import {
+    MasterImagesCommand,
+    MasterImagesEventQueueRouterRouting,
+    MasterImagesTaskQueueRouterRouting,
+} from '../constants';
+import type {
+    MasterImagesCommandContext,
+    MasterImagesCommandMap,
+    MasterImagesEventContext,
+    MasterImagesEventMap,
+} from '../types';
+
+export class MasterImageQueueService {
+    protected cache : Cache;
+
+    protected queueRouter : QueueRouter;
+
+    constructor() {
+        this.cache = useCache();
+        this.queueRouter = useQueueRouter();
+    }
+
+    // -------------------------------------------------
+
+    async publishCommand(ctx: MasterImagesCommandContext) {
+        const isLocked = await this.isCommandLocked(ctx.command);
+        if (isLocked) {
+            throw new Error('The command is locked and can therefore not be executed.');
+        }
+
+        const routerPayload = this.buildRouterPayloadForCommand(ctx);
+        await this.queueRouter.publish(routerPayload);
+
+        if (ctx.command === MasterImagesCommand.SYNCHRONIZE) {
+            await this.setCommandLock(ctx.command);
+        }
+    }
+
+    async consumeCommands(
+        handlers: QueueRouterHandlers<Partial<MasterImagesCommandMap>>,
+    ) {
+        await this.queueRouter.consume(MasterImagesTaskQueueRouterRouting, {
+            $any: async (message) => {
+                if (handlers[message.type]) {
+                    await handlers[message.type](message, this);
+                }
+
+                if (handlers.$any) {
+                    await handlers.$any(message);
+                }
+            },
+        });
+    }
+
+    // -------------------------------------------------
+
+    async publishEvent(ctx: MasterImagesEventContext) {
+        const routerPayload = this.buildRouterPayloadForEvent(ctx);
+        await this.queueRouter.publish(routerPayload);
+    }
+
+    async consumeEvents(
+        handlers: QueueRouterHandlers<Partial<MasterImagesEventMap>>,
+    ) {
+        await this.queueRouter.consume(MasterImagesEventQueueRouterRouting, {
+            $any: async (message) => {
+                await this.setCommandLock(MasterImagesCommand.SYNCHRONIZE);
+
+                if (handlers[message.type]) {
+                    await handlers[message.type](message);
+                }
+
+                if (handlers.$any) {
+                    await handlers.$any(message);
+                }
+            },
+        });
+    }
+
+    // -------------------------------------------------
+
+    protected async setCommandLock(command: string) {
+        await this.cache.set(`master-images-command:${command}`, true, {
+            ttl: 1000 * 60,
+        });
+    }
+
+    protected async isCommandLocked(command: string) {
+        const isActive = await this.cache.get(`master-images-command:${command}`);
+
+        return !!isActive;
+    }
+
+    // -------------------------------------------------
+
+    protected buildRouterPayloadForEvent(context: MasterImagesEventContext) {
+        return buildQueueRouterPublishPayload({
+            type: context.event,
+            data: cleanupPayload(context.data),
+            metadata: {
+                routing: MasterImagesEventQueueRouterRouting,
+            },
+        });
+    }
+
+    protected buildRouterPayloadForCommand(context: MasterImagesCommandContext) {
+        return buildQueueRouterPublishPayload({
+            type: context.command,
+            data: cleanupPayload(context.data),
+            metadata: {
+                routing: MasterImagesTaskQueueRouterRouting,
+            },
+        });
+    }
+}

package/src/components/master-images/service/singleton.ts

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import { singa } from 'singa';
+import { MasterImageQueueService } from './module';
+
+const instance = singa<MasterImageQueueService>({
+    name: 'masterImageQueue',
+    factory: () => new MasterImageQueueService(),
+});
+
+export function useMasterImageQueueService() {
+    return instance.use();
+}

package/src/components/master-images/synchronize/index.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+export * from './types';

package/src/components/master-images/synchronize/types.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import type { MasterImageCommandArgument } from '@privateaim/core-kit';
+
+export type MasterImageSyncData = {
+    name: string,
+    path: string,
+    virtualPath: string,
+    command: string,
+    commandArguments?: MasterImageCommandArgument[]
+};
+
+export type MasterImageGroupSyncData = {
+    name: string,
+    path: string,
+    virtualPath: string,
+};
+
+export type MasterImagesSynchronizeCommandPayload = {
+    owner: string,
+    repository: string,
+    branch: string
+};
+
+export type MasterImagesSynchronizationFailedEventPayload = {
+    error: Error
+};
+
+export type MaterImagesSynchronizedEventPayload = {
+    images: MasterImageSyncData[],
+    groups: MasterImageGroupSyncData[]
+};

package/src/components/master-images/types.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2023-2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import type {
+    MasterImagesBuildCommandPayload, MasterImagesBuildFailedEventPayload,
+    MasterImagesBuildingEventPayload,
+    MasterImagesBuiltEventPayload,
+} from './build';
+import type { MasterImagesCommand, MasterImagesEvent } from './constants';
+import type {
+    MasterImagesPushCommandPayload,
+    MasterImagesPushEventPayload, MasterImagesPushFailedEventPayload,
+} from './push';
+import type {
+    MasterImagesSynchronizationFailedEventPayload, MasterImagesSynchronizeCommandPayload,
+    MaterImagesSynchronizedEventPayload,
+} from './synchronize';
+
+//-----------------------------------------------------------------------
+
+type MasterImagesCommandMapRaw = {
+    [MasterImagesCommand.BUILD]: MasterImagesBuildCommandPayload,
+    [MasterImagesCommand.PUSH]: MasterImagesPushCommandPayload,
+    [MasterImagesCommand.SYNCHRONIZE]: MasterImagesSynchronizeCommandPayload,
+};
+
+export type MasterImagesCommandMap = {
+    [K in keyof MasterImagesCommandMapRaw as `${K}`]: MasterImagesCommandMapRaw[K]
+};
+
+export type MasterImagesCommandContext = {
+    [K in keyof MasterImagesCommandMap]: {
+        command: K,
+        data: MasterImagesCommandMap[K]
+    }
+}[keyof MasterImagesCommandMap];
+
+//-----------------------------------------------------------------------
+
+type MasterImagesEventMapRaw = {
+    [MasterImagesEvent.BUILDING]: MasterImagesBuildingEventPayload,
+    [MasterImagesEvent.BUILT]: MasterImagesBuiltEventPayload,
+    [MasterImagesEvent.BUILD_FAILED]: MasterImagesBuildFailedEventPayload,
+
+    [MasterImagesEvent.PUSHING]: MasterImagesPushEventPayload,
+    [MasterImagesEvent.PUSHED]: MasterImagesPushEventPayload,
+    [MasterImagesEvent.PUSH_FAILED]: MasterImagesPushFailedEventPayload,
+
+    [MasterImagesEvent.SYNCHRONIZING]: Record<string, any>,
+    [MasterImagesEvent.SYNCHRONIZED]: MaterImagesSynchronizedEventPayload,
+    [MasterImagesEvent.SYNCHRONIZATION_FAILED]: MasterImagesSynchronizationFailedEventPayload
+};
+
+export type MasterImagesEventMap = {
+    [K in keyof MasterImagesEventMapRaw as `${K}`]: MasterImagesEventMapRaw[K]
+};
+
+export type MasterImagesEventContext = {
+    [K in keyof MasterImagesEventMap]: {
+        event: K,
+        data: MasterImagesEventMap[K]
+    }
+}[keyof MasterImagesEventMap];

package/src/constants.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+export enum ComponentName {
+    BUILDER = 'builder',
+    CORE = 'core',
+    MASTER_IMAGES = 'masterImages',
+}
+
+export enum ErrorCode {
+    NOT_FOUND = 'notFound',
+    REGISTRY_NOT_FOUND = 'registryNotFound',
+    REGISTRY_PROJECT_NOT_FOUND = 'registryProjectNotFound',
+    NONE = 'none',
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+export * from './components';
+export * from './constants';

package/src/utils.ts

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import { hasOwnProperty } from '@privateaim/kit';
+
+export function cleanupPayload<T extends Record<string, any>>(payload: T): T {
+    if (hasOwnProperty(payload, 'entity')) {
+        delete payload.entity;
+    }
+
+    if (hasOwnProperty(payload, 'registry')) {
+        delete payload.registry;
+    }
+
+    return payload;
+}

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+    "extends": "../../tsconfig.build.json",
+
+    "compilerOptions": {
+        "outDir": "./dist"
+    },
+
+    "include": [
+        "src/**/*.ts"
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "paths": {
+            "@privateaim/core-kit": ["./packages/core-kit/src"],
+            "@privateaim/kit": ["./packages/kit/src"],
+            "@privateaim/server-kit": ["./packages/server-kit/src"]
+        }
+    }
+}