@hexabot-ai/api 3.2.2-alpha.1 → 3.2.2-alpha.11

package/src/mcp/types.ts

@@ -0,0 +1,14 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import type { User } from '@hexabot-ai/types';
+import type { Request } from 'express';
+
+export type HexabotMcpRequest = Request & {
+  user?: User;
+  hexabotUser?: User;
+  mcpTokenId?: string;
+};

package/src/transfer/adapters/content-type-transfer.adapter.ts

@@ -0,0 +1,154 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import { isDeepStrictEqual } from 'node:util';
+
+import {
+  type WorkflowExportBundle,
+  type WorkflowExportBundleContentType,
+  type WorkflowImportResourceResult,
+} from '@hexabot-ai/types';
+import { ConflictException, Injectable } from '@nestjs/common';
+import { In } from 'typeorm';
+
+import { ContentTypeOrmEntity } from '@/cms/entities/content-type.entity';
+import { ContentTypeService } from '@/cms/services/content-type.service';
+
+import {
+  WorkflowTransferAdapter,
+  WorkflowTransferExportContext,
+  WorkflowTransferImportContext,
+  WorkflowTransferResourceAdapter,
+} from '../workflow-transfer-resource-adapter';
+import {
+  assertFoundAll,
+  buildPostCreateEvent,
+  buildResourceResult,
+  uniqueResourceIds,
+  type WorkflowTransferImportAdapterResult,
+} from '../workflow-transfer.types';
+
+@WorkflowTransferAdapter()
+@Injectable()
+export class ContentTypeTransferAdapter extends WorkflowTransferResourceAdapter {
+  override readonly kind = 'contentType';
+
+  override readonly resourceKeys = ['contentTypes'];
+
+  constructor(private readonly contentTypeService: ContentTypeService) {
+    super();
+  }
+
+  override async buildExportResources(
+    ctx: WorkflowTransferExportContext,
+  ): Promise<Record<string, WorkflowExportBundleContentType[]>> {
+    return {
+      contentTypes: await this.buildContentTypeExportResources(
+        ctx.getRefs(this.kind),
+      ),
+    };
+  }
+
+  private async buildContentTypeExportResources(
+    ids: string[],
+  ): Promise<WorkflowExportBundleContentType[]> {
+    const uniqueIds = uniqueResourceIds(ids);
+    if (uniqueIds.length === 0) {
+      return [];
+    }
+
+    const contentTypes = await this.contentTypeService.find({
+      where: { id: In(uniqueIds) },
+    });
+    assertFoundAll(
+      'content type',
+      uniqueIds,
+      contentTypes.map((contentType) => contentType.id),
+    );
+
+    return contentTypes.map((contentType) => ({
+      exportId: contentType.id,
+      name: contentType.name,
+      schema: contentType.schema,
+    }));
+  }
+
+  override async importResources(
+    ctx: WorkflowTransferImportContext,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const contentTypes =
+      ctx.getResources<
+        WorkflowExportBundle['resources']['contentTypes'][number]
+      >('contentTypes');
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+
+    for (const contentType of contentTypes) {
+      const existing = await ctx.manager.findOne(ContentTypeOrmEntity, {
+        where: { name: contentType.name },
+      });
+
+      if (existing) {
+        if (!this.isEquivalentContentType(existing, contentType)) {
+          throw new ConflictException(
+            `Content type "${contentType.name}" already exists with different configuration`,
+          );
+        }
+
+        idMap[contentType.exportId] = existing.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'contentType',
+            exportId: contentType.exportId,
+            localId: existing.id,
+            name: contentType.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const payload = {
+        name: contentType.name,
+        schema: contentType.schema,
+      };
+      const created = await ctx.manager.save(
+        ContentTypeOrmEntity,
+        ctx.manager.create(ContentTypeOrmEntity, payload),
+      );
+
+      idMap[contentType.exportId] = created.id;
+      resources.push(
+        buildResourceResult({
+          kind: 'contentType',
+          exportId: contentType.exportId,
+          localId: created.id,
+          name: contentType.name,
+          action: 'created',
+        }),
+      );
+      postCreateEvents.push(
+        buildPostCreateEvent('contentType', created, payload),
+      );
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings: [],
+      postCreateEvents,
+    };
+  }
+
+  private isEquivalentContentType(
+    existing: ContentTypeOrmEntity,
+    imported: WorkflowExportBundle['resources']['contentTypes'][number],
+  ): boolean {
+    return isDeepStrictEqual(existing.schema, imported.schema);
+  }
+}

package/src/transfer/adapters/credential-transfer.adapter.ts

@@ -0,0 +1,158 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  type WorkflowExportBundleCredential,
+  type WorkflowImportResourceResult,
+} from '@hexabot-ai/types';
+import { ConflictException, Injectable } from '@nestjs/common';
+import { In } from 'typeorm';
+
+import { CredentialOrmEntity } from '@/user/entities/credential.entity';
+import { CredentialService } from '@/user/services/credential.service';
+
+import {
+  WorkflowTransferAdapter,
+  WorkflowTransferExportContext,
+  WorkflowTransferImportContext,
+  WorkflowTransferResourceAdapter,
+} from '../workflow-transfer-resource-adapter';
+import {
+  assertFoundAll,
+  buildPostCreateEvent,
+  buildResourceResult,
+  PLACEHOLDER_CREDENTIAL_VALUE,
+  uniqueResourceIds,
+  type WorkflowTransferImportAdapterResult,
+} from '../workflow-transfer.types';
+
+@WorkflowTransferAdapter()
+@Injectable()
+export class CredentialTransferAdapter extends WorkflowTransferResourceAdapter {
+  override readonly kind = 'credential';
+
+  override readonly resourceKeys = ['credentials'];
+
+  constructor(private readonly credentialService: CredentialService) {
+    super();
+  }
+
+  override async buildExportResources(
+    ctx: WorkflowTransferExportContext,
+  ): Promise<Record<string, WorkflowExportBundleCredential[]>> {
+    return {
+      credentials: await this.buildCredentialExportResources(
+        ctx.getRefs(this.kind),
+      ),
+    };
+  }
+
+  private async buildCredentialExportResources(
+    ids: string[],
+  ): Promise<WorkflowExportBundleCredential[]> {
+    const uniqueIds = uniqueResourceIds(ids);
+    if (uniqueIds.length === 0) {
+      return [];
+    }
+
+    const credentials = await this.credentialService.find({
+      where: { id: In(uniqueIds) },
+    });
+    assertFoundAll(
+      'credential',
+      uniqueIds,
+      credentials.map((credential) => credential.id),
+    );
+
+    return credentials.map((credential) => ({
+      exportId: credential.id,
+      name: credential.name,
+      exportedOwnerId: credential.owner,
+    }));
+  }
+
+  override async importResources(
+    ctx: WorkflowTransferImportContext,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const credentials =
+      ctx.getResources<WorkflowExportBundleCredential>('credentials');
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const warnings: string[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+    const placeholderExportIds = new Set<string>();
+
+    for (const credential of credentials) {
+      const existingByName = await ctx.manager.findOne(CredentialOrmEntity, {
+        where: { name: credential.name },
+        relations: ['owner'],
+      });
+
+      if (existingByName) {
+        const existingOwnerId =
+          existingByName.owner && typeof existingByName.owner === 'object'
+            ? existingByName.owner.id
+            : null;
+        if (existingOwnerId !== ctx.ownerId) {
+          throw new ConflictException(
+            `Credential "${credential.name}" already exists for another user`,
+          );
+        }
+
+        idMap[credential.exportId] = existingByName.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'credential',
+            exportId: credential.exportId,
+            localId: existingByName.id,
+            name: credential.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const payload = {
+        name: credential.name,
+        value: PLACEHOLDER_CREDENTIAL_VALUE,
+        owner: { id: ctx.ownerId },
+      };
+      const created = await ctx.manager.save(
+        CredentialOrmEntity,
+        ctx.manager.create(CredentialOrmEntity, payload),
+      );
+
+      idMap[credential.exportId] = created.id;
+      placeholderExportIds.add(credential.exportId);
+      resources.push(
+        buildResourceResult({
+          kind: 'credential',
+          exportId: credential.exportId,
+          localId: created.id,
+          name: credential.name,
+          action: 'placeholder_created',
+        }),
+      );
+      postCreateEvents.push(
+        buildPostCreateEvent('credential', created, payload),
+      );
+      warnings.push(
+        `Credential "${credential.name}" was imported as a placeholder and must be updated before use.`,
+      );
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings,
+      postCreateEvents,
+      metadata: {
+        placeholderExportIds,
+      },
+    };
+  }
+}

package/src/transfer/adapters/label-transfer.adapter.ts

@@ -0,0 +1,291 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2026 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+import {
+  type WorkflowExportBundle,
+  type WorkflowExportBundleLabel,
+  type WorkflowExportBundleLabelGroup,
+  type WorkflowImportResourceResult,
+} from '@hexabot-ai/types';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+} from '@nestjs/common';
+import { EntityManager, In } from 'typeorm';
+
+import { LabelGroupOrmEntity } from '@/chat/entities/label-group.entity';
+import { LabelOrmEntity } from '@/chat/entities/label.entity';
+import { LabelService } from '@/chat/services/label.service';
+
+import {
+  WorkflowTransferAdapter,
+  WorkflowTransferExportContext,
+  WorkflowTransferImportContext,
+  WorkflowTransferResourceAdapter,
+} from '../workflow-transfer-resource-adapter';
+import {
+  assertFoundAll,
+  buildPostCreateEvent,
+  buildResourceResult,
+  uniqueResourceIds,
+  type WorkflowTransferImportAdapterResult,
+} from '../workflow-transfer.types';
+
+type LabelExportResources = {
+  labelGroups: WorkflowExportBundleLabelGroup[];
+  labels: WorkflowExportBundleLabel[];
+};
+
+@WorkflowTransferAdapter()
+@Injectable()
+export class LabelTransferAdapter extends WorkflowTransferResourceAdapter {
+  override readonly kind = 'label';
+
+  override readonly resourceKeys = ['labels', 'labelGroups'];
+
+  constructor(private readonly labelService: LabelService) {
+    super();
+  }
+
+  override async buildExportResources(
+    ctx: WorkflowTransferExportContext,
+  ): Promise<Record<string, unknown[]>> {
+    return this.buildLabelExportResources(ctx.getRefs(this.kind));
+  }
+
+  private async buildLabelExportResources(
+    ids: string[],
+  ): Promise<LabelExportResources> {
+    const uniqueIds = uniqueResourceIds(ids);
+    if (uniqueIds.length === 0) {
+      return { labelGroups: [], labels: [] };
+    }
+
+    const labels = await this.labelService.findAndPopulate({
+      where: { id: In(uniqueIds) },
+    });
+    assertFoundAll(
+      'label',
+      uniqueIds,
+      labels.map((label) => label.id),
+    );
+
+    const groupsById = new Map<string, WorkflowExportBundleLabelGroup>();
+    for (const label of labels) {
+      if (label.group?.id) {
+        groupsById.set(label.group.id, {
+          exportId: label.group.id,
+          name: label.group.name,
+        });
+      }
+    }
+
+    return {
+      labelGroups: Array.from(groupsById.values()),
+      labels: labels.map((label) => ({
+        exportId: label.id,
+        title: label.title,
+        name: label.name,
+        description: label.description ?? null,
+        groupExportId: label.group?.id ?? null,
+      })),
+    };
+  }
+
+  override async importResources(
+    ctx: WorkflowTransferImportContext,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const labelGroups =
+      ctx.getResources<
+        WorkflowExportBundle['resources']['labelGroups'][number]
+      >('labelGroups');
+    const labels =
+      ctx.getResources<WorkflowExportBundle['resources']['labels'][number]>(
+        'labels',
+      );
+    const groupResult = await this.importLabelGroups(ctx.manager, labelGroups);
+    const labelResult = await this.importLabels(
+      ctx.manager,
+      labels,
+      groupResult.idMap,
+    );
+
+    return {
+      idMap: labelResult.idMap,
+      resources: [...groupResult.resources, ...labelResult.resources],
+      warnings: [],
+      postCreateEvents: [
+        ...groupResult.postCreateEvents,
+        ...labelResult.postCreateEvents,
+      ],
+    };
+  }
+
+  private async importLabelGroups(
+    manager: EntityManager,
+    labelGroups: WorkflowExportBundle['resources']['labelGroups'],
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+
+    for (const labelGroup of labelGroups) {
+      const existing = await manager.findOne(LabelGroupOrmEntity, {
+        where: { name: labelGroup.name },
+      });
+
+      if (existing) {
+        idMap[labelGroup.exportId] = existing.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'labelGroup',
+            exportId: labelGroup.exportId,
+            localId: existing.id,
+            name: labelGroup.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const payload = {
+        name: labelGroup.name,
+      };
+      const created = await manager.save(
+        LabelGroupOrmEntity,
+        manager.create(LabelGroupOrmEntity, payload),
+      );
+
+      idMap[labelGroup.exportId] = created.id;
+      resources.push(
+        buildResourceResult({
+          kind: 'labelGroup',
+          exportId: labelGroup.exportId,
+          localId: created.id,
+          name: labelGroup.name,
+          action: 'created',
+        }),
+      );
+      postCreateEvents.push(
+        buildPostCreateEvent('labelGroup', created, payload),
+      );
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings: [],
+      postCreateEvents,
+    };
+  }
+
+  private async importLabels(
+    manager: EntityManager,
+    labels: WorkflowExportBundle['resources']['labels'],
+    labelGroupIdMap: Record<string, string>,
+  ): Promise<WorkflowTransferImportAdapterResult> {
+    const idMap: Record<string, string> = {};
+    const resources: WorkflowImportResourceResult[] = [];
+    const postCreateEvents: WorkflowTransferImportAdapterResult['postCreateEvents'] =
+      [];
+
+    for (const label of labels) {
+      const groupId = label.groupExportId
+        ? labelGroupIdMap[label.groupExportId]
+        : null;
+
+      if (label.groupExportId && !groupId) {
+        throw new BadRequestException(
+          `Workflow bundle is missing label group "${label.groupExportId}" required by label "${label.name}"`,
+        );
+      }
+
+      const existingByName = await manager.findOne(LabelOrmEntity, {
+        where: { name: label.name },
+        relations: ['group'],
+      });
+
+      if (existingByName) {
+        if (!this.isEquivalentLabel(existingByName, label, groupId)) {
+          throw new ConflictException(
+            `Label "${label.name}" already exists with different configuration`,
+          );
+        }
+
+        idMap[label.exportId] = existingByName.id;
+        resources.push(
+          buildResourceResult({
+            kind: 'label',
+            exportId: label.exportId,
+            localId: existingByName.id,
+            name: label.name,
+            action: 'reused',
+          }),
+        );
+        continue;
+      }
+
+      const existingByTitle = await manager.findOne(LabelOrmEntity, {
+        where: { title: label.title },
+      });
+      if (existingByTitle) {
+        throw new ConflictException(
+          `Label title "${label.title}" already exists with a different name`,
+        );
+      }
+
+      const payload = {
+        title: label.title,
+        name: label.name,
+        description: label.description ?? null,
+        group: groupId ? { id: groupId } : null,
+        builtin: false,
+      };
+      const created = await manager.save(
+        LabelOrmEntity,
+        manager.create(LabelOrmEntity, payload),
+      );
+
+      idMap[label.exportId] = created.id;
+      resources.push(
+        buildResourceResult({
+          kind: 'label',
+          exportId: label.exportId,
+          localId: created.id,
+          name: label.name,
+          action: 'created',
+        }),
+      );
+      postCreateEvents.push(buildPostCreateEvent('label', created, payload));
+    }
+
+    return {
+      idMap,
+      resources,
+      warnings: [],
+      postCreateEvents,
+    };
+  }
+
+  private isEquivalentLabel(
+    existing: LabelOrmEntity,
+    imported: WorkflowExportBundle['resources']['labels'][number],
+    importedGroupId: string | null,
+  ): boolean {
+    const existingGroupId =
+      existing.group && typeof existing.group === 'object'
+        ? existing.group.id
+        : null;
+
+    return (
+      existing.title === imported.title &&
+      (existing.description ?? null) === (imported.description ?? null) &&
+      existingGroupId === importedGroupId
+    );
+  }
+}