Refactor twenty client sdk provisioning for logic function and front-component (#18544)

## 1. The `twenty-client-sdk` Package (Source of Truth) The monorepo package at `packages/twenty-client-sdk` ships with: - A **pre-built metadata client** (static, generated from a fixed schema) - A **stub core client** that throws at runtime (`CoreApiClient was not generated...`) - Both ESM (`.mjs`) and CJS (`.cjs`) bundles in `dist/` - A `package.json` with proper `exports` map for `twenty-client-sdk/core`, `twenty-client-sdk/metadata`, and `twenty-client-sdk/generate` ## 2. Generation & Upload (Server-Side, at Migration Time) **When**: `WorkspaceMigrationRunnerService.run()` executes after a metadata schema change. **What happens in `SdkClientGenerationService.generateAndStore()`**: 1. Copies the stub `twenty-client-sdk` package from the server's assets (resolved via `SDK_CLIENT_PACKAGE_DIRNAME` — from `dist/assets/twenty-client-sdk/` in production, or from `node_modules` in dev) 2. Filters out `node_modules/` and `src/` during copy — only `package.json` + `dist/` are kept (like an npm publish) 3. Calls `replaceCoreClient()` which uses `@genql/cli` to introspect the **application-scoped** GraphQL schema and generates a real `CoreApiClient`, then compiles it to ESM+CJS and overwrites `dist/core.mjs` and `dist/core.cjs` 4. Archives the **entire package** (with `package.json` + `dist/`) into `twenty-client-sdk.zip` 5. Uploads the single archive to S3 under `FileFolder.GeneratedSdkClient` 6. Sets `isSdkLayerStale = true` on the `ApplicationEntity` in the database ## 3. Invalidation Signal The `isSdkLayerStale` boolean column on `ApplicationEntity` is the invalidation mechanism: - **Set to `true`** by `generateAndStore()` after uploading a new client archive - **Checked** by both logic function drivers before execution — if `true`, they rebuild their local layer - **Set back to `false`** by `markSdkLayerFresh()` after the driver has successfully consumed the new archive Default is `false` so existing applications without a generated client aren't affected. ## 4a. Logic Functions — Local Driver **`ensureSdkLayer()`** is called before every execution: 1. Checks if the local SDK layer directory exists AND `isSdkLayerStale` is `false` → early return 2. Otherwise, cleans the local layer directory 3. Calls `downloadAndExtractToPackage()` which streams the zip from S3 directly to disk and extracts the full package into `<tmpdir>/sdk/<workspaceId>-<appId>/node_modules/twenty-client-sdk/` 4. Calls `markSdkLayerFresh()` to set `isSdkLayerStale = false` **At execution time**, `assembleNodeModules()` symlinks everything from the deps layer's `node_modules/` **except** `twenty-client-sdk`, which is symlinked from the SDK layer instead. This ensures the logic function's `import ... from 'twenty-client-sdk/core'` resolves to the generated client. ## 4b. Logic Functions — Lambda Driver **`ensureSdkLayer()`** is called during `build()`: 1. Checks if `isSdkLayerStale` is `false` and an existing Lambda layer ARN exists → early return 2. Otherwise, deletes all existing layer versions for this SDK layer name 3. Calls `downloadArchiveBuffer()` to get the raw zip from S3 (no disk extraction) 4. Calls `reprefixZipEntries()` which streams the zip entries into a **new zip** with the path prefix `nodejs/node_modules/twenty-client-sdk/` — this is the Lambda layer convention path. All done in memory, no disk round-trip 5. Publishes the re-prefixed zip as a new Lambda layer via `publishLayer()` 6. Calls `markSdkLayerFresh()` **At function creation**, the Lambda is created with **two layers**: `[depsLayerArn, sdkLayerArn]`. The SDK layer is listed last so it overwrites the stub `twenty-client-sdk` from the deps layer (later layers take precedence in Lambda's `/opt` merge). ## 5. Front Components Front components are built by `app:build` with `twenty-client-sdk/core` and `twenty-client-sdk/metadata` as **esbuild externals**. The stored `.mjs` in S3 has unresolved bare import specifiers like `import { CoreApiClient } from 'twenty-client-sdk/core'`. SDK import resolution is split between the **frontend host** (fetching & caching SDK modules) and the **Web Worker** (rewriting imports): **Server endpoints**: - `GET /rest/front-components/:id` — `FrontComponentService.getBuiltComponentStream()` returns the **raw `.mjs`** directly from file storage. No bundling, no SDK injection. - `GET /rest/sdk-client/:applicationId/:moduleName` — `SdkClientController` reads a single file (e.g. `dist/core.mjs`) from the generated SDK archive via `SdkClientGenerationService.readFileFromArchive()` and serves it as JavaScript. **Frontend host** (`FrontComponentRenderer` in `twenty-front`): 1. Queries `FindOneFrontComponent` which returns `applicationId`, `builtComponentChecksum`, `usesSdkClient`, and `applicationTokenPair` 2. If `usesSdkClient` is `true`, renders `FrontComponentRendererWithSdkClient` which calls the `useApplicationSdkClient` hook 3. `useApplicationSdkClient({ applicationId, accessToken })` checks the Jotai atom family cache for existing blob URLs. On cache miss, fetches both SDK modules from `GET /rest/sdk-client/:applicationId/core` and `/metadata`, creates **blob URLs** for each, and stores them in the atom family 4. Once the blob URLs are cached, passes them as `sdkClientUrls` (already blob URLs, not server URLs) to `SharedFrontComponentRenderer` → `FrontComponentWorkerEffect` → worker's `render()` call via `HostToWorkerRenderContext` **Worker** (`remote-worker.ts` in `twenty-sdk`): 1. Fetches the raw component `.mjs` source as text 2. If `sdkClientUrls` are provided and the source contains SDK import specifiers (`twenty-client-sdk/core`, `twenty-client-sdk/metadata`), **rewrites** the bare specifiers to the blob URLs received from the host (e.g. `'twenty-client-sdk/core'` → `'blob:...'`) 3. Creates a blob URL for the rewritten source and `import()`s it 4. Revokes only the component blob URL after the module is loaded — the SDK blob URLs are owned and managed by the host's Jotai cache This approach eliminates server-side esbuild bundling on every request, caches SDK modules per application in the frontend, and keeps the worker's job to a simple string rewrite. ## Summary Diagram ``` app:build (SDK) └─ twenty-client-sdk stub (metadata=real, core=stub) │ ▼ WorkspaceMigrationRunnerService.run() └─ SdkClientGenerationService.generateAndStore() ├─ Copy stub package (package.json + dist/) ├─ replaceCoreClient() → regenerate core.mjs/core.cjs ├─ Zip entire package → upload to S3 └─ Set isSdkLayerStale = true │ ┌────────┴────────────────────┐ ▼ ▼ Logic Functions Front Components │ │ ├─ Local Driver ├─ GET /rest/sdk-client/:appId/core │ └─ downloadAndExtract │ → core.mjs from archive │ → symlink into │ │ node_modules ├─ Host (useApplicationSdkClient) │ │ ├─ Fetch SDK modules └─ Lambda Driver │ ├─ Create blob URLs └─ downloadArchiveBuffer │ └─ Cache in Jotai atom family → reprefixZipEntries │ → publish as Lambda ├─ GET /rest/front-components/:id layer │ → raw .mjs (no bundling) │ └─ Worker (browser) ├─ Fetch component .mjs ├─ Rewrite imports → blob URLs └─ import() rewritten source ``` ## Next PR - Estimate perf improvement by implementing a redis caching for front component client storage ( we don't even cache front comp initially ) - Implem frontent blob invalidation sse event from server --------- Co-authored-by: Charles Bochet <charlesBochet@users.noreply.github.com>
2026-03-24 19:10:25 +01:00
parent 16451ee2ee
commit 4ea2e32366
189 changed files with 12487 additions and 9856 deletions
@@ -0,0 +1,3 @@
+export const ALLOWED_SDK_MODULES = ['core', 'metadata'] as const;
+
+export type SdkModuleName = (typeof ALLOWED_SDK_MODULES)[number];
@@ -0,0 +1,13 @@
+import path from 'path';
+
+import { ASSET_PATH } from 'src/constants/assets-path';
+
+const IS_BUILT =
+  __dirname.includes('/dist/') && process.env.NODE_ENV !== 'development';
+
+// In built mode the package is copied into dist/assets/ by the build step.
+// In dev mode it lives in node_modules via the monorepo workspace — resolve
+// from the twenty-client-sdk/core entry point and navigate up to the package root.
+export const SDK_CLIENT_PACKAGE_DIRNAME = IS_BUILT
+  ? path.join(ASSET_PATH, 'twenty-client-sdk')
+  : path.resolve(require.resolve('twenty-client-sdk/core'), '..', '..');
@@ -0,0 +1,69 @@
+import {
+  Controller,
+  Get,
+  NotFoundException,
+  Param,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
+
+import { Response } from 'express';
+import { isDefined } from 'twenty-shared/utils';
+
+import {
+  ALLOWED_SDK_MODULES,
+  type SdkModuleName,
+} from 'src/engine/core-modules/sdk-client/constants/allowed-sdk-modules';
+import { SdkClientArchiveService } from 'src/engine/core-modules/sdk-client/sdk-client-archive.service';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+@Controller('rest/sdk-client')
+@UseGuards(WorkspaceAuthGuard)
+export class SdkClientController {
+  constructor(
+    private readonly workspaceCacheService: WorkspaceCacheService,
+    private readonly sdkClientArchiveService: SdkClientArchiveService,
+  ) {}
+
+  @Get(':applicationId/:moduleName')
+  @UseGuards(NoPermissionGuard)
+  async getSdkModule(
+    @Res() res: Response,
+    @Param('applicationId') applicationId: string,
+    @Param('moduleName') moduleName: SdkModuleName,
+    @AuthWorkspace() workspace: WorkspaceEntity,
+  ) {
+    if (!ALLOWED_SDK_MODULES.includes(moduleName)) {
+      throw new NotFoundException(
+        `SDK module "${moduleName}" not found. Allowed: ${ALLOWED_SDK_MODULES.join(', ')}`,
+      );
+    }
+
+    const { flatApplicationMaps } =
+      await this.workspaceCacheService.getOrRecompute(workspace.id, [
+        'flatApplicationMaps',
+      ]);
+
+    const application = flatApplicationMaps.byId[applicationId];
+
+    if (!isDefined(application)) {
+      throw new NotFoundException(
+        `Application "${applicationId}" not found in workspace "${workspace.id}"`,
+      );
+    }
+
+    const fileBuffer =
+      await this.sdkClientArchiveService.getClientModuleFromArchive({
+        workspaceId: workspace.id,
+        applicationUniversalIdentifier: application.universalIdentifier,
+        moduleName,
+      });
+
+    res.setHeader('Content-Type', 'application/javascript');
+    res.send(fileBuffer);
+  }
+}
@@ -0,0 +1,42 @@
+import { type MessageDescriptor } from '@lingui/core';
+import { msg } from '@lingui/core/macro';
+import { assertUnreachable } from 'twenty-shared/utils';
+
+import { CustomException } from 'src/utils/custom-exception';
+
+export enum SdkClientExceptionCode {
+  ARCHIVE_NOT_FOUND = 'ARCHIVE_NOT_FOUND',
+  ARCHIVE_EXTRACTION_FAILED = 'ARCHIVE_EXTRACTION_FAILED',
+  FILE_NOT_FOUND_IN_ARCHIVE = 'FILE_NOT_FOUND_IN_ARCHIVE',
+  GENERATION_FAILED = 'GENERATION_FAILED',
+}
+
+const getSdkClientExceptionUserFriendlyMessage = (
+  code: SdkClientExceptionCode,
+) => {
+  switch (code) {
+    case SdkClientExceptionCode.ARCHIVE_NOT_FOUND:
+      return msg`SDK client archive not found. The SDK client may not have been generated for this application.`;
+    case SdkClientExceptionCode.ARCHIVE_EXTRACTION_FAILED:
+      return msg`Failed to extract SDK client archive.`;
+    case SdkClientExceptionCode.FILE_NOT_FOUND_IN_ARCHIVE:
+      return msg`File not found in SDK client archive.`;
+    case SdkClientExceptionCode.GENERATION_FAILED:
+      return msg`Failed to generate SDK client.`;
+    default:
+      assertUnreachable(code);
+  }
+};
+
+export class SdkClientException extends CustomException<SdkClientExceptionCode> {
+  constructor(
+    message: string,
+    code: SdkClientExceptionCode,
+    { userFriendlyMessage }: { userFriendlyMessage?: MessageDescriptor } = {},
+  ) {
+    super(message, code, {
+      userFriendlyMessage:
+        userFriendlyMessage ?? getSdkClientExceptionUserFriendlyMessage(code),
+    });
+  }
+}
@@ -0,0 +1,166 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { createWriteStream } from 'fs';
+import * as fs from 'fs/promises';
+import { join } from 'path';
+import { type Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+
+import { FileFolder } from 'twenty-shared/types';
+import { Repository } from 'typeorm';
+
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import {
+  FileStorageException,
+  FileStorageExceptionCode,
+} from 'src/engine/core-modules/file-storage/interfaces/file-storage-exception';
+import { TemporaryDirManager } from 'src/engine/core-modules/logic-function/logic-function-drivers/utils/temporary-dir-manager';
+import { type SdkModuleName } from 'src/engine/core-modules/sdk-client/constants/allowed-sdk-modules';
+import {
+  SdkClientException,
+  SdkClientExceptionCode,
+} from 'src/engine/core-modules/sdk-client/exceptions/sdk-client.exception';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { streamToBuffer } from 'src/utils/stream-to-buffer';
+
+const SDK_CLIENT_ARCHIVE_NAME = 'twenty-client-sdk.zip';
+
+@Injectable()
+export class SdkClientArchiveService {
+  constructor(
+    private readonly fileStorageService: FileStorageService,
+    @InjectRepository(ApplicationEntity)
+    private readonly applicationRepository: Repository<ApplicationEntity>,
+    private readonly workspaceCacheService: WorkspaceCacheService,
+  ) {}
+
+  async downloadAndExtractToPackage({
+    workspaceId,
+    applicationUniversalIdentifier,
+    targetPackagePath,
+  }: {
+    workspaceId: string;
+    applicationUniversalIdentifier: string;
+    targetPackagePath: string;
+  }): Promise<void> {
+    const temporaryDirManager = new TemporaryDirManager();
+
+    try {
+      const { sourceTemporaryDir } = await temporaryDirManager.init();
+      const archivePath = join(sourceTemporaryDir, SDK_CLIENT_ARCHIVE_NAME);
+
+      const archiveStream = await this.readArchiveStream({
+        workspaceId,
+        applicationUniversalIdentifier,
+      });
+
+      await pipeline(archiveStream, createWriteStream(archivePath));
+
+      await fs.rm(targetPackagePath, { recursive: true, force: true });
+      await fs.mkdir(targetPackagePath, { recursive: true });
+
+      const { default: unzipper } = await import('unzipper');
+      const directory = await unzipper.Open.file(archivePath);
+
+      await directory.extract({ path: targetPackagePath });
+    } finally {
+      await temporaryDirManager.clean();
+    }
+  }
+
+  async downloadArchiveBuffer({
+    workspaceId,
+    applicationUniversalIdentifier,
+  }: {
+    workspaceId: string;
+    applicationUniversalIdentifier: string;
+  }): Promise<Buffer> {
+    const archiveStream = await this.readArchiveStream({
+      workspaceId,
+      applicationUniversalIdentifier,
+    });
+
+    return streamToBuffer(archiveStream);
+  }
+
+  async getClientModuleFromArchive({
+    workspaceId,
+    applicationUniversalIdentifier,
+    moduleName,
+  }: {
+    workspaceId: string;
+    applicationUniversalIdentifier: string;
+    moduleName: SdkModuleName;
+  }): Promise<Buffer> {
+    const filePath = `dist/${moduleName}.mjs`;
+
+    const archiveBuffer = await this.downloadArchiveBuffer({
+      workspaceId,
+      applicationUniversalIdentifier,
+    });
+
+    const { default: unzipper } = await import('unzipper');
+    const directory = await unzipper.Open.buffer(archiveBuffer);
+
+    const entry = directory.files.find(
+      (file) => file.path === filePath || file.path === `./${filePath}`,
+    );
+
+    if (!entry) {
+      throw new SdkClientException(
+        `Module "${moduleName}" not found in SDK client archive for application "${applicationUniversalIdentifier}" in workspace "${workspaceId}"`,
+        SdkClientExceptionCode.FILE_NOT_FOUND_IN_ARCHIVE,
+      );
+    }
+
+    return entry.buffer();
+  }
+
+  async markSdkLayerFresh({
+    applicationId,
+    workspaceId,
+  }: {
+    applicationId: string;
+    workspaceId: string;
+  }): Promise<void> {
+    await this.applicationRepository.update(
+      { id: applicationId, workspaceId },
+      { isSdkLayerStale: false },
+    );
+
+    await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [
+      'flatApplicationMaps',
+    ]);
+  }
+
+  private async readArchiveStream({
+    workspaceId,
+    applicationUniversalIdentifier,
+  }: {
+    workspaceId: string;
+    applicationUniversalIdentifier: string;
+  }): Promise<Readable> {
+    try {
+      return await this.fileStorageService.readFile({
+        workspaceId,
+        applicationUniversalIdentifier,
+        fileFolder: FileFolder.GeneratedSdkClient,
+        resourcePath: SDK_CLIENT_ARCHIVE_NAME,
+      });
+    } catch (error) {
+      if (
+        error instanceof FileStorageException &&
+        error.code === FileStorageExceptionCode.FILE_NOT_FOUND
+      ) {
+        throw new SdkClientException(
+          `SDK client archive "${SDK_CLIENT_ARCHIVE_NAME}" not found for application "${applicationUniversalIdentifier}" in workspace "${workspaceId}".`,
+          SdkClientExceptionCode.ARCHIVE_NOT_FOUND,
+        );
+      }
+
+      throw error;
+    }
+  }
+}
@@ -0,0 +1,131 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import * as fs from 'fs/promises';
+import { printSchema } from 'graphql';
+import path, { join } from 'path';
+
+import { replaceCoreClient } from 'twenty-client-sdk/generate';
+import { FileFolder } from 'twenty-shared/types';
+import { Repository } from 'typeorm';
+
+import { WorkspaceSchemaFactory } from 'src/engine/api/graphql/workspace-schema.factory';
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { createZipFile } from 'src/engine/core-modules/logic-function/logic-function-drivers/utils/create-zip-file';
+import { TemporaryDirManager } from 'src/engine/core-modules/logic-function/logic-function-drivers/utils/temporary-dir-manager';
+import { SDK_CLIENT_PACKAGE_DIRNAME } from 'src/engine/core-modules/sdk-client/constants/sdk-client-package-dirname';
+import {
+  SdkClientException,
+  SdkClientExceptionCode,
+} from 'src/engine/core-modules/sdk-client/exceptions/sdk-client.exception';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const SDK_CLIENT_ARCHIVE_NAME = 'twenty-client-sdk.zip';
+
+@Injectable()
+export class SdkClientGenerationService {
+  private readonly logger = new Logger(SdkClientGenerationService.name);
+
+  constructor(
+    private readonly fileStorageService: FileStorageService,
+    @InjectRepository(ApplicationEntity)
+    private readonly applicationRepository: Repository<ApplicationEntity>,
+    private readonly workspaceCacheService: WorkspaceCacheService,
+    private readonly workspaceSchemaFactory: WorkspaceSchemaFactory,
+  ) {}
+
+  async generateSdkClientForApplication({
+    workspaceId,
+    applicationId,
+    applicationUniversalIdentifier,
+  }: {
+    workspaceId: string;
+    applicationId: string;
+    applicationUniversalIdentifier: string;
+  }): Promise<void> {
+    const graphqlSchema = await this.workspaceSchemaFactory.createGraphQLSchema(
+      { id: workspaceId } as WorkspaceEntity,
+      applicationId,
+    );
+
+    await this.generateAndStore({
+      workspaceId,
+      applicationId,
+      applicationUniversalIdentifier,
+      schema: printSchema(graphqlSchema),
+    });
+
+    this.logger.log(
+      `Generated SDK client for application ${applicationUniversalIdentifier}`,
+    );
+  }
+
+  private async generateAndStore({
+    workspaceId,
+    applicationId,
+    applicationUniversalIdentifier,
+    schema,
+  }: {
+    workspaceId: string;
+    applicationId: string;
+    applicationUniversalIdentifier: string;
+    schema: string;
+  }): Promise<void> {
+    const temporaryDirManager = new TemporaryDirManager();
+
+    try {
+      const { sourceTemporaryDir } = await temporaryDirManager.init();
+
+      const tempPackageRoot = join(sourceTemporaryDir, 'twenty-client-sdk');
+
+      await fs.cp(SDK_CLIENT_PACKAGE_DIRNAME, tempPackageRoot, {
+        recursive: true,
+        filter: (source) => {
+          const relativePath = path.relative(
+            SDK_CLIENT_PACKAGE_DIRNAME,
+            source,
+          );
+
+          return (
+            !relativePath.includes('node_modules') &&
+            !relativePath.startsWith('src')
+          );
+        },
+      });
+
+      await replaceCoreClient({ packageRoot: tempPackageRoot, schema });
+
+      const archivePath = join(sourceTemporaryDir, SDK_CLIENT_ARCHIVE_NAME);
+
+      await createZipFile(tempPackageRoot, archivePath);
+
+      await this.fileStorageService.writeFile({
+        workspaceId,
+        applicationUniversalIdentifier,
+        fileFolder: FileFolder.GeneratedSdkClient,
+        resourcePath: SDK_CLIENT_ARCHIVE_NAME,
+        sourceFile: await fs.readFile(archivePath),
+        mimeType: 'application/zip',
+        settings: { isTemporaryFile: false, toDelete: false },
+      });
+
+      await this.applicationRepository.update(
+        { id: applicationId, workspaceId },
+        { isSdkLayerStale: true },
+      );
+
+      await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [
+        'flatApplicationMaps',
+      ]);
+    } catch (error) {
+      throw new SdkClientException(
+        `Failed to generate SDK client for application "${applicationUniversalIdentifier}" in workspace "${workspaceId}": ${error instanceof Error ? error.message : String(error)}`,
+        SdkClientExceptionCode.GENERATION_FAILED,
+      );
+    } finally {
+      await temporaryDirManager.clean();
+    }
+  }
+}
@@ -0,0 +1,21 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { CoreGraphQLApiModule } from 'src/engine/api/graphql/core-graphql-api.module';
+
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import { SdkClientController } from 'src/engine/core-modules/sdk-client/controllers/sdk-client.controller';
+import { SdkClientArchiveService } from 'src/engine/core-modules/sdk-client/sdk-client-archive.service';
+import { SdkClientGenerationService } from 'src/engine/core-modules/sdk-client/sdk-client-generation.service';
+import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([ApplicationEntity]),
+    WorkspaceCacheModule,
+    CoreGraphQLApiModule,
+  ],
+  controllers: [SdkClientController],
+  providers: [SdkClientGenerationService, SdkClientArchiveService],
+  exports: [SdkClientGenerationService, SdkClientArchiveService],
+})
+export class SdkClientModule {}