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

package/src/utils/test/utils.ts

@@ -14,6 +14,7 @@ import {
   DataSource,
   DataSourceOptions,
   EntitySchema,
+  EntitySubscriberInterface,
   EntityTarget,
   getMetadataArgsStorage,
 } from 'typeorm';
@@ -33,7 +34,7 @@ import { SettingModule } from '@/setting/setting.module';
 
 import { I18nTestingModule } from './modules/i18n-testing.module';
 import { I18nServiceProvider } from './providers/i18n-service.provider';
-import { registerTypeOrmDataSource } from './test';
+import { registerTestingModule, registerTypeOrmDataSource } from './test';
 
 type TTypeOrToken = [
   new (...args: any[]) => any,
@@ -51,12 +52,16 @@ type TypeOrmTestingConfig = {
   fixtures?: TypeOrmFixture | TypeOrmFixture[];
   dataSourceOptions?: Partial<DataSourceOptions>;
 };
+type TypeOrmTestingInput =
+  | TypeOrmTestingConfig
+  | TypeOrmTestingConfig[]
+  | false;
 
 type buildTestingMocksProps<
   P extends ModuleMetadata['providers'] = ModuleMetadata['providers'],
   C extends ModuleMetadata['controllers'] = ModuleMetadata['controllers'],
 > = ModuleMetadata & {
-  typeorm?: TypeOrmTestingConfig | TypeOrmTestingConfig[];
+  typeorm?: TypeOrmTestingInput;
 } & (
     | {
         providers: NonNullable<P>;
@@ -108,7 +113,10 @@ const getParamTypes = (provider: Provider) =>
  * @param parentClass - The root provider class whose dependency graph is resolved.
  * @returns A complete array of unique provider dependencies.
  */
-const getClassDependencies = (parentClass: Provider): Provider[] => {
+const getClassDependencies = (
+  parentClass: Provider,
+  providedTokens = new Set<Provider>(),
+): Provider[] => {
   const dependencies: Provider[] = [];
   const seenClasses = new Set<Provider>();
   const classQueue: Provider[] = [parentClass];
@@ -124,7 +132,11 @@ const getClassDependencies = (parentClass: Provider): Provider[] => {
 
     if (currentClass) {
       getParamTypes(currentClass).forEach((paramType: Provider) => {
-        if (paramType && !seenClasses.has(paramType)) {
+        if (
+          paramType &&
+          !seenClasses.has(paramType) &&
+          !providedTokens.has(paramType)
+        ) {
           classQueue.push(paramType);
           dependencies.push(paramType);
         }
@@ -136,6 +148,17 @@ const getClassDependencies = (parentClass: Provider): Provider[] => {
 };
 const filterNestedDependencies = (dependency: Provider) =>
   dependency.valueOf().toString().slice(0, 6) === 'class ';
+const resolveProviderToken = (provider: Provider): Provider | undefined => {
+  if (
+    typeof provider === 'object' &&
+    provider !== null &&
+    'provide' in provider
+  ) {
+    return provider.provide as Provider;
+  }
+
+  return provider;
+};
 /**
  * Identifies nested class-based dependencies to be automatically injected into test modules.
  *
@@ -145,9 +168,14 @@ const filterNestedDependencies = (dependency: Provider) =>
 const autoInjectExclusions = new Set<Provider>([DataSource]);
 const getNestedDependencies = (providers: Provider[]): Provider[] => {
   const nestedDependencies = new Set<Provider>();
+  const providedTokens = new Set<Provider>(
+    providers
+      .map(resolveProviderToken)
+      .filter((provider): provider is Provider => provider !== undefined),
+  );
 
   providers.filter(filterNestedDependencies).forEach((provider) => {
-    getClassDependencies(provider)
+    getClassDependencies(provider, providedTokens)
       .filter(filterNestedDependencies)
       .forEach((dependency) => {
         if (autoInjectExclusions.has(dependency)) {
@@ -213,15 +241,56 @@ const buildEntityLookup = () => {
 
   return lookup;
 };
-const registeredSubscribers = new Set<unknown>();
+const addEntityToLookup = (
+  lookup: Map<string, EntityTarget<any>>,
+  entity: EntityTarget<any> | undefined,
+): EntityTarget<any> | undefined => {
+  if (!entity) {
+    return undefined;
+  }
+
+  const key = resolveEntityTargetName(entity);
+  if (key) {
+    lookup.set(key, entity);
+  }
+
+  return entity;
+};
+const refreshEntityLookup = (lookup: Map<string, EntityTarget<any>>): void => {
+  buildEntityLookup().forEach((entity, key) => lookup.set(key, entity));
+};
+const GENERATED_ORM_HOOK_SUBSCRIBER = Symbol('generatedOrmHookSubscriber');
+type SubscriberWithListenTo = EntitySubscriberInterface & {
+  listenTo: NonNullable<EntitySubscriberInterface['listenTo']>;
+};
+type GeneratedOrmHookSubscriber = SubscriberWithListenTo & {
+  [GENERATED_ORM_HOOK_SUBSCRIBER]: true;
+};
+const isGeneratedOrmHookSubscriber = (
+  subscriber: unknown,
+): subscriber is GeneratedOrmHookSubscriber =>
+  Boolean(
+    subscriber &&
+      typeof subscriber === 'object' &&
+      (subscriber as Record<PropertyKey, unknown>)[
+        GENERATED_ORM_HOOK_SUBSCRIBER
+      ],
+  );
+const hasListenTo = (
+  subscriber: unknown,
+): subscriber is SubscriberWithListenTo =>
+  Boolean(
+    subscriber &&
+      typeof subscriber === 'object' &&
+      typeof (subscriber as { listenTo?: unknown }).listenTo === 'function',
+  );
 const registerAllRepositorySubscribers = (
   dataSource: DataSource,
   entityClasses: (new (...args: any[]) => BaseOrmEntity<any>)[],
 ): void => {
   for (const EntityClass of entityClasses) {
-    if (registeredSubscribers.has(EntityClass)) continue;
-
     const subscriber = {
+      [GENERATED_ORM_HOOK_SUBSCRIBER]: true,
       listenTo: () => EntityClass,
       ...Object.fromEntries(
         ORM_HOOK_NAMES.map((name) => [
@@ -238,14 +307,34 @@ const registerAllRepositorySubscribers = (
       ),
     };
     const exists = dataSource.subscribers.some(
-      (s) => typeof s.listenTo === 'function' && s.listenTo() === EntityClass,
+      (subscriber) =>
+        hasListenTo(subscriber) && subscriber.listenTo() === EntityClass,
     );
     if (!exists) {
       dataSource.subscribers.push(subscriber as any);
-      registeredSubscribers.add(EntityClass);
     }
   }
 };
+const pruneGeneratedRepositorySubscribers = (dataSource: DataSource): void => {
+  const concreteSubscriberTargets = new Set(
+    dataSource.subscribers
+      .filter(
+        (subscriber): subscriber is SubscriberWithListenTo =>
+          !isGeneratedOrmHookSubscriber(subscriber) && hasListenTo(subscriber),
+      )
+      .map((subscriber) => subscriber.listenTo()),
+  );
+  const subscribers = dataSource.subscribers.filter(
+    (subscriber) =>
+      !isGeneratedOrmHookSubscriber(subscriber) ||
+      !concreteSubscriberTargets.has(subscriber.listenTo()),
+  );
+  dataSource.subscribers.splice(
+    0,
+    dataSource.subscribers.length,
+    ...subscribers,
+  );
+};
 const normalizeRepositoryToken = (token: string): string | undefined => {
   if (!token.endsWith(TYPEORM_REPOSITORY_SUFFIX)) {
     return undefined;
@@ -314,22 +403,41 @@ const extractInjectTokensFromProvider = (provider: ProviderLike): unknown[] => {
 
   return [];
 };
-const registerMetadataEntities = (
-  currentEntities: Set<EntityTarget<any>>,
-  lookup: Map<string, EntityTarget<any>>,
-): void => {
-  lookup.forEach((entity) => currentEntities.add(entity));
+const dependsOnDataSource = (provider: ProviderLike): boolean => {
+  if (!provider) {
+    return false;
+  }
+
+  if (typeof provider === 'function') {
+    return (
+      getParamTypes(provider).includes(DataSource) ||
+      extractCustomInjectTokens(provider).includes(DataSource)
+    );
+  }
+
+  if (typeof provider === 'object') {
+    if ('useClass' in provider && typeof provider.useClass === 'function') {
+      return dependsOnDataSource(provider.useClass);
+    }
+
+    if ('inject' in provider && Array.isArray(provider.inject)) {
+      return provider.inject.includes(DataSource);
+    }
+  }
+
+  return false;
 };
 const registerAutoDetectedTypeOrmEntities = (
   currentEntities: Set<EntityTarget<any>>,
   providers: Provider[],
   controllers: ModuleMetadata['controllers'],
   lookup: Map<string, EntityTarget<any>>,
-) => {
+): boolean => {
   if (!lookup.size) {
-    return;
+    return false;
   }
 
+  let detected = false;
   const controllerList = Array.isArray(controllers) ? controllers : [];
   const tokens = [
     ...providers.flatMap(extractInjectTokensFromProvider),
@@ -340,8 +448,147 @@ const registerAutoDetectedTypeOrmEntities = (
     const entity = resolveEntityFromToken(token, lookup);
     if (entity) {
       currentEntities.add(entity);
+      detected = true;
     }
   });
+
+  return detected;
+};
+const addEntityToSet = (
+  entities: Set<EntityTarget<any>>,
+  entity: EntityTarget<any> | undefined,
+  queue: EntityTarget<any>[],
+): void => {
+  if (!entity || entities.has(entity)) {
+    return;
+  }
+
+  entities.add(entity);
+  queue.push(entity);
+};
+const isSameEntityTarget = (
+  left: EntityTarget<any> | undefined,
+  right: EntityTarget<any>,
+): boolean => {
+  if (!left) {
+    return false;
+  }
+
+  if (left === right) {
+    return true;
+  }
+
+  const leftName = resolveEntityTargetName(left);
+  const rightName = resolveEntityTargetName(right);
+
+  return !!leftName && leftName === rightName;
+};
+const resolveRelationTarget = async (
+  relationType: unknown,
+  lookup: Map<string, EntityTarget<any>>,
+): Promise<EntityTarget<any> | undefined> => {
+  if (typeof relationType === 'string') {
+    return lookup.get(relationType);
+  }
+
+  if (typeof relationType === 'function') {
+    try {
+      const resolved = relationType();
+
+      if (typeof resolved === 'string') {
+        return resolveRelationTarget(resolved, lookup);
+      }
+
+      return addEntityToLookup(lookup, resolved as EntityTarget<any>);
+    } catch {
+      return addEntityToLookup(lookup, relationType as EntityTarget<any>);
+    }
+  }
+
+  return undefined;
+};
+const registerInheritedTypeOrmEntities = (
+  currentEntities: Set<EntityTarget<any>>,
+  entity: EntityTarget<any>,
+  lookup: Map<string, EntityTarget<any>>,
+  queue: EntityTarget<any>[],
+): void => {
+  if (typeof entity !== 'function') {
+    return;
+  }
+
+  let prototype = Object.getPrototypeOf(entity.prototype);
+
+  while (prototype?.constructor && prototype.constructor !== Object) {
+    const parent = lookup.get(prototype.constructor.name);
+    if (parent) {
+      addEntityToSet(currentEntities, parent, queue);
+    }
+
+    prototype = Object.getPrototypeOf(prototype);
+  }
+};
+const registerChildTypeOrmEntities = (
+  currentEntities: Set<EntityTarget<any>>,
+  entity: EntityTarget<any>,
+  lookup: Map<string, EntityTarget<any>>,
+  queue: EntityTarget<any>[],
+): void => {
+  if (typeof entity !== 'function') {
+    return;
+  }
+
+  getMetadataArgsStorage().tables.forEach((table) => {
+    if (
+      table.type !== 'entity-child' ||
+      typeof table.target !== 'function' ||
+      !entity.prototype.isPrototypeOf(table.target.prototype)
+    ) {
+      return;
+    }
+
+    addEntityToSet(
+      currentEntities,
+      addEntityToLookup(lookup, table.target as EntityTarget<any>),
+      queue,
+    );
+  });
+};
+const registerRelatedTypeOrmEntities = async (
+  currentEntities: Set<EntityTarget<any>>,
+  lookup: Map<string, EntityTarget<any>>,
+): Promise<void> => {
+  const queue = Array.from(currentEntities);
+
+  while (queue.length > 0) {
+    const entity = queue.shift()!;
+    const storage = getMetadataArgsStorage();
+
+    refreshEntityLookup(lookup);
+    registerInheritedTypeOrmEntities(currentEntities, entity, lookup, queue);
+    registerChildTypeOrmEntities(currentEntities, entity, lookup, queue);
+
+    const relations = storage.relations.filter((relation) =>
+      isSameEntityTarget(relation.target as EntityTarget<any>, entity),
+    );
+
+    for (const relation of relations) {
+      const relationEntity = await resolveRelationTarget(relation.type, lookup);
+      addEntityToSet(currentEntities, relationEntity, queue);
+    }
+
+    for (const relation of storage.relations) {
+      const relationEntity = await resolveRelationTarget(relation.type, lookup);
+
+      if (isSameEntityTarget(relationEntity, entity)) {
+        addEntityToSet(
+          currentEntities,
+          addEntityToLookup(lookup, relation.target as EntityTarget<any>),
+          queue,
+        );
+      }
+    }
+  }
 };
 
 /**
@@ -421,27 +668,33 @@ export const buildTestingMocks = async ({
         overrideTokens.has(provider as unknown as Provider)
       ),
   );
-  const defaultTypeOrmEntities: EntityTarget<any>[] = [
-    SettingOrmEntity,
-    MetadataOrmEntity,
-    LanguageOrmEntity,
-  ];
-  const typeOrmEntities = new Set<EntityTarget<any>>(defaultTypeOrmEntities);
+  const typeOrmDisabled = typeorm === false;
+  let typeOrmOptions: Partial<DataSourceOptions> | undefined;
+  const typeOrmFixtures: TypeOrmFixture[] = [];
+  const typeOrmConfigs =
+    !typeOrmDisabled && Array.isArray(typeorm)
+      ? typeorm.filter(Boolean)
+      : !typeOrmDisabled && typeorm
+        ? [typeorm]
+        : [];
+  const hasExplicitTypeOrmConfig = typeOrmConfigs.length > 0;
+  const typeOrmEntities = new Set<EntityTarget<any>>();
   const entityLookup = buildEntityLookup();
-  registerMetadataEntities(typeOrmEntities, entityLookup);
-  registerAutoDetectedTypeOrmEntities(
+  const hasTypeOrmEntityDependencies = registerAutoDetectedTypeOrmEntities(
     typeOrmEntities,
     providersList,
     controllers,
     entityLookup,
   );
-  let typeOrmOptions: Partial<DataSourceOptions> | undefined;
-  const typeOrmFixtures: TypeOrmFixture[] = [];
-  const typeOrmConfigs = Array.isArray(typeorm)
-    ? typeorm.filter(Boolean)
-    : typeorm
-      ? [typeorm]
-      : [];
+  const controllerList = Array.isArray(controllers) ? controllers : [];
+  const hasDataSourceDependencies = [...providersList, ...controllerList].some(
+    dependsOnDataSource,
+  );
+  const shouldUseTypeOrm =
+    !typeOrmDisabled &&
+    (hasExplicitTypeOrmConfig ||
+      hasTypeOrmEntityDependencies ||
+      hasDataSourceDependencies);
 
   typeOrmConfigs.forEach((config) => {
     config.entities?.forEach((entity) => typeOrmEntities.add(entity));
@@ -459,43 +712,61 @@ export const buildTestingMocks = async ({
     }
   });
 
+  if (shouldUseTypeOrm && typeOrmEntities.size === 0) {
+    entityLookup.forEach((entity) => typeOrmEntities.add(entity));
+  }
+
+  if (shouldUseTypeOrm) {
+    [SettingOrmEntity, MetadataOrmEntity, LanguageOrmEntity].forEach((entity) =>
+      typeOrmEntities.add(entity),
+    );
+    await registerRelatedTypeOrmEntities(typeOrmEntities, entityLookup);
+  }
+
   const runTypeOrmFixtures = async (dataSource: DataSource) => {
     for (const fixture of typeOrmFixtures) {
       await fixture(dataSource);
     }
   };
   const entitiesArray = Array.from(typeOrmEntities);
-  const baseOptions: DataSourceOptions = {
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    logging: false,
-    entities: entitiesArray,
-    ...(typeOrmOptions ?? {}),
-  } as DataSourceOptions;
-  const dataSource = new DataSource(baseOptions);
-  await dataSource.initialize();
-  registerAllRepositorySubscribers(dataSource, entitiesArray as any[]);
-  await runTypeOrmFixtures(dataSource);
-  registerTypeOrmDataSource(dataSource);
-
-  const typeOrmRootModule: DynamicModule = TypeOrmModule.forRootAsync({
-    useFactory: async () => baseOptions as DataSourceOptions,
-    dataSourceFactory: async () => dataSource,
-  });
-  const typeOrmProviders = entitiesArray.map((entity) => ({
-    provide: getRepositoryToken(entity as any),
-    useValue: dataSource.getRepository(entity),
-  }));
+  let typeOrmRootModule: DynamicModule | undefined;
+  let typeOrmProviders: Provider[] = [];
+  let typeOrmDataSource: DataSource | undefined;
+
+  if (shouldUseTypeOrm) {
+    const baseOptions: DataSourceOptions = {
+      type: 'better-sqlite3',
+      database: ':memory:',
+      synchronize: true,
+      dropSchema: true,
+      logging: false,
+      entities: entitiesArray,
+      ...(typeOrmOptions ?? {}),
+    } as DataSourceOptions;
+    const dataSource = new DataSource(baseOptions);
+    await dataSource.initialize();
+    typeOrmDataSource = dataSource;
+    registerAllRepositorySubscribers(dataSource, entitiesArray as any[]);
+    await runTypeOrmFixtures(dataSource);
+    registerTypeOrmDataSource(dataSource);
+
+    typeOrmRootModule = TypeOrmModule.forRootAsync({
+      useFactory: async () => baseOptions as DataSourceOptions,
+      dataSourceFactory: async () => dataSource,
+    });
+    typeOrmProviders = entitiesArray.map((entity) => ({
+      provide: getRepositoryToken(entity as any),
+      useValue: dataSource.getRepository(entity),
+    }));
+  }
+
   const testingModuleBuilder = Test.createTestingModule({
     imports: [
       LoggerModule,
       EventEmitterModule.forRoot({ global: true }),
       CacheModule.register({ isGlobal: true }),
-      typeOrmRootModule,
       I18nTestingModule,
-      SettingModule,
+      ...(typeOrmRootModule ? [typeOrmRootModule, SettingModule] : []),
       ...imports,
     ],
     providers: [
@@ -507,6 +778,10 @@ export const buildTestingMocks = async ({
     ...rest,
   });
   const module = await testingModuleBuilder.compile();
+  if (typeOrmDataSource) {
+    pruneGeneratedRepositorySubscribers(typeOrmDataSource);
+  }
+  registerTestingModule(module);
 
   return {
     module,

package/src/websocket/websocket.gateway.ts

@@ -18,6 +18,7 @@ import {
   WebSocketGateway,
   WebSocketServer,
 } from '@nestjs/websockets';
+import { isUUID } from 'class-validator';
 import Cookie from 'cookie';
 import signature from 'cookie-signature';
 import { Request } from 'express';
@@ -25,7 +26,6 @@ import { Session as ExpressSession, SessionData } from 'express-session';
 import { ExtendedError, Server, Socket } from 'socket.io';
 import { DataSource } from 'typeorm';
 import { sync as uid } from 'uid-safe';
-import { validate as isUuid } from 'uuid';
 
 import { SourceOrmEntity } from '@/channel/entities/source.entity';
 import { config } from '@/config';
@@ -179,7 +179,7 @@ export class WebsocketGateway
   }
 
   private normalizeSourceId(value: string | null): string | null {
-    if (!value || !isUuid(value)) {
+    if (!value || !isUUID(value)) {
       return null;
     }
 

package/src/workflow/contexts/workflow-runtime.context.ts

@@ -9,7 +9,7 @@ import { WorkflowRunFull } from '@hexabot-ai/types';
 import { forwardRef, Inject, Injectable, Scope } from '@nestjs/common';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 
-import { ActionService } from '@/actions';
+import { ActionService } from '@/actions/actions.service';
 import { MessageService } from '@/chat/services/message.service';
 import { SubscriberService } from '@/chat/services/subscriber.service';
 import { ContentTypeService } from '@/cms/services/content-type.service';
@@ -17,7 +17,7 @@ import { ContentService } from '@/cms/services/content.service';
 import { I18nService } from '@/i18n/services/i18n.service';
 import { LoggerService } from '@/logger/logger.service';
 import { SettingService } from '@/setting/services/setting.service';
-import { CredentialService } from '@/user';
+import { CredentialService } from '@/user/services/credential.service';
 import { cloneObject } from '@/utils/helpers/clone';
 import { WorkflowContextState, WorkflowType } from '@/workflow/types';
 

package/src/workflow/controllers/workflow.controller.ts

@@ -27,8 +27,8 @@ import { DeleteResult } from 'typeorm/driver/mongodb/typings';
 
 import { ActionService } from '@/actions/actions.service';
 import { I18nService } from '@/i18n/services/i18n.service';
-import { UserService } from '@/user';
-import { UuidParam } from '@/utils';
+import { UserService } from '@/user/services/user.service';
+import { UuidParam } from '@/utils/decorators/uuid-param.decorator';
 import { BaseOrmController } from '@/utils/generics/base-orm.controller';
 import { PopulatePipe } from '@/utils/pipes/populate.pipe';
 import { TypeOrmSearchFilterPipe } from '@/utils/pipes/typeorm-search-filter.pipe';

package/src/workflow/entities/mcp-server.entity.ts

@@ -24,8 +24,8 @@ import {
   OnBeforeUpdate,
 } from '@/database/decorators/orm-event-hooks.decorator';
 import { BaseOrmEntity } from '@/database/entities/base.entity';
-import { CredentialOrmEntity } from '@/user';
-import { AsRelation } from '@/utils';
+import { CredentialOrmEntity } from '@/user/entities/credential.entity';
+import { AsRelation } from '@/utils/decorators/relation-ref.decorator';
 
 import { McpServerDto } from '../dto/mcp-server.dto';
 import { McpServerTransport } from '../types';

package/src/workflow/entities/workflow-version.entity.ts

@@ -5,6 +5,7 @@
  */
 
 import { createHash } from 'crypto';
+import { createRequire } from 'node:module';
 
 import {
   workflowVersionSchema,
@@ -32,7 +33,9 @@ import { AsRelation } from '@/utils';
 import { WorkflowVersionDto } from '../dto/workflow-version.dto';
 import { WorkflowVersionAction } from '../types';
 
-import { WorkflowOrmEntity } from './workflow.entity';
+import type { WorkflowOrmEntity } from './workflow.entity';
+
+const requireEntity = createRequire(__filename);
 
 @Entity({ name: 'workflow_versions' })
 @Index(['workflow', 'version'], { unique: true })
@@ -42,7 +45,7 @@ export class WorkflowVersionOrmEntity extends BaseOrmEntity<WorkflowVersionDto>
   fullCls = workflowVersionFullSchema;
 
   /** Workflow that owns this version snapshot. */
-  @ManyToOne(() => WorkflowOrmEntity, {
+  @ManyToOne(() => requireEntity('./workflow.entity').WorkflowOrmEntity, {
     nullable: false,
     onDelete: 'CASCADE',
   })
@@ -130,7 +133,9 @@ export class WorkflowVersionOrmEntity extends BaseOrmEntity<WorkflowVersionDto>
       return;
     }
 
-    const workflowRepository = event.manager.getRepository(WorkflowOrmEntity);
+    const WorkflowEntity = requireEntity('./workflow.entity').WorkflowOrmEntity;
+    const workflowRepository =
+      event.manager.getRepository<WorkflowOrmEntity>(WorkflowEntity);
     const workflow = await workflowRepository.findOne({
       where: { id: workflowId },
     });

package/src/workflow/entities/workflow.entity.ts

@@ -181,7 +181,8 @@ export class WorkflowOrmEntity extends BaseOrmEntity<WorkflowDto> {
       });
       await event.manager.save(WorkflowVersionOrmEntity, version);
     } catch (error: any) {
-      if (error.code !== 'SQLITE_CONSTRAINT') {
+      const code = error?.code ?? error?.driverError?.code;
+      if (typeof code !== 'string' || !code.startsWith('SQLITE_CONSTRAINT')) {
         throw error;
       }
     }

package/src/workflow/services/memory.service.ts

@@ -40,6 +40,7 @@ export class MemoryService {
     const records = await this.memoryRecordService.findActiveByScope({
       ownerId,
       workflowId,
+      threadId,
       runId,
     });
 

package/src/workflow/services/workflow-scheduler.service.ts

@@ -13,7 +13,7 @@ import { RemoveEvent } from 'typeorm';
 import { AppInstance } from '@/app.instance';
 import { config } from '@/config';
 import { LoggerService } from '@/logger/logger.service';
-import { UserService } from '@/user';
+import { UserService } from '@/user/services/user.service';
 import {
   InsertEntityEvent,
   UpdateEntityEvent,