@agentlang/agentmanager 0.0.3

package/libs/common/src/database/embedded-database.service.ts

@@ -0,0 +1,120 @@
+import {
+  Injectable,
+  Logger,
+  OnModuleInit,
+  OnModuleDestroy,
+  Inject,
+} from '@nestjs/common';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { DATABASE_CONFIG, DatabaseModuleConfig } from './database.config';
+import { DatabaseConnectionHolder } from './database-connection.holder';
+
+@Injectable()
+export class EmbeddedDatabaseService implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(EmbeddedDatabaseService.name);
+  private embeddedPg: {
+    initialise: () => Promise<void>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    createDatabase: (name: string) => Promise<void>;
+  } | null = null;
+
+  constructor(
+    @Inject(DATABASE_CONFIG)
+    private readonly config: DatabaseModuleConfig,
+    private readonly connectionHolder: DatabaseConnectionHolder,
+  ) {}
+
+  async onModuleInit() {
+    if (this.connectionHolder.isConfigured()) {
+      this.logger.log(
+        'Database already configured — skipping embedded Postgres, using external database',
+      );
+      return;
+    }
+
+    let EmbeddedPostgres: new (
+      opts: Record<string, unknown>,
+    ) => typeof this.embeddedPg;
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      let imported = require('embedded-postgres');
+      // Handle both default and named exports
+      if (imported.default) {
+        imported = imported.default;
+      }
+      EmbeddedPostgres = imported;
+    } catch {
+      this.logger.warn(
+        'embedded-postgres package not installed — skipping embedded database. Install with: npm install embedded-postgres',
+      );
+      return;
+    }
+
+    const port = this.config.embeddedDbPort;
+    const dbName = this.config.embeddedDbName;
+    const databaseDir = resolve(this.config.dataPath, 'db');
+
+    this.logger.log(
+      `Starting embedded Postgres on port ${port} (data: ${databaseDir})`,
+    );
+
+    const dbUser = this.config.database.user;
+    const dbPassword = this.config.database.password;
+
+    this.embeddedPg = new EmbeddedPostgres({
+      databaseDir,
+      user: dbUser,
+      password: dbPassword,
+      port,
+      persistent: true,
+      onLog: () => {},
+      onError: (err: Error) =>
+        this.logger.error(`[embedded-postgres] ${err.message}`),
+    });
+
+    try {
+      // Check if cluster is already initialized
+      const pgVersionFile = resolve(databaseDir, 'PG_VERSION');
+      if (!existsSync(pgVersionFile)) {
+        await this.embeddedPg!.initialise();
+      }
+
+      await this.embeddedPg!.start();
+
+      try {
+        await this.embeddedPg!.createDatabase(dbName);
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (!msg.includes('already exists')) throw err;
+      }
+
+      // Update connection holder so other services use this instance
+      this.connectionHolder.set({
+        host: 'localhost',
+        port,
+        user: dbUser,
+        password: dbPassword,
+      });
+
+      this.logger.log(
+        `Embedded Postgres started on port ${port}, database "${dbName}" ready`,
+      );
+    } catch (err) {
+      this.logger.error(`Failed to start embedded Postgres: ${err}`);
+      this.embeddedPg = null;
+    }
+  }
+
+  async onModuleDestroy() {
+    if (this.embeddedPg) {
+      this.logger.log('Stopping embedded Postgres');
+      try {
+        await this.embeddedPg.stop();
+      } catch (err) {
+        this.logger.error(`Failed to stop embedded Postgres: ${err}`);
+      }
+    }
+  }
+}

package/libs/common/src/database/file-store.factory.ts

@@ -0,0 +1,20 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { resolve } from 'node:path';
+import { DATABASE_CONFIG, DatabaseModuleConfig } from './database.config';
+import { FileStore } from './file-store';
+
+@Injectable()
+export class FileStoreFactory {
+  private readonly dataPath: string;
+
+  constructor(
+    @Inject(DATABASE_CONFIG)
+    private readonly config: DatabaseModuleConfig,
+  ) {
+    this.dataPath = this.config.dataPath;
+  }
+
+  create<T>(filename: string): FileStore<T> {
+    return new FileStore<T>(resolve(this.dataPath, filename));
+  }
+}

package/libs/common/src/database/file-store.ts

@@ -0,0 +1,47 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { Logger } from '@nestjs/common';
+
+const DEBOUNCE_MS = 100;
+
+export class FileStore<T> {
+  private readonly logger = new Logger(FileStore.name);
+  private writeTimer: ReturnType<typeof setTimeout> | null = null;
+  private pendingData: T | null = null;
+
+  constructor(private readonly filePath: string) {}
+
+  async load(): Promise<T | null> {
+    try {
+      const raw = await readFile(this.filePath, 'utf-8');
+      return JSON.parse(raw) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  save(data: T): void {
+    this.pendingData = data;
+    if (!this.writeTimer) {
+      this.writeTimer = setTimeout(() => {
+        void this.flush();
+      }, DEBOUNCE_MS);
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (this.writeTimer) {
+      clearTimeout(this.writeTimer);
+      this.writeTimer = null;
+    }
+    const data = this.pendingData;
+    if (data === null) return;
+    this.pendingData = null;
+    try {
+      await mkdir(dirname(this.filePath), { recursive: true });
+      await writeFile(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+    } catch (err) {
+      this.logger.error(`Failed to persist ${this.filePath}: ${err}`);
+    }
+  }
+}

package/libs/common/src/errors/domain.error.ts

@@ -0,0 +1,11 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export class DomainError extends HttpException {
+  constructor(
+    message: string,
+    status: HttpStatus | number = HttpStatus.INTERNAL_SERVER_ERROR,
+  ) {
+    super(message, status);
+    this.name = this.constructor.name;
+  }
+}

package/libs/common/src/filters/domain-exception.filter.ts

@@ -0,0 +1,62 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { DomainError } from '../errors/domain.error';
+
+/**
+ * Catches all exceptions and normalises responses.
+ *
+ * Handles two cases:
+ *  1. HttpExceptions (including DomainError subclasses)
+ *  2. Unexpected errors → 500
+ */
+@Catch()
+export class DomainExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(DomainExceptionFilter.name);
+
+  constructor(private readonly httpAdapterHost: HttpAdapterHost) {}
+
+  catch(exception: unknown, host: ArgumentsHost) {
+    const { httpAdapter } = this.httpAdapterHost;
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+
+    if (exception instanceof DomainError) {
+      httpAdapter.reply(
+        response,
+        { error: exception.message },
+        exception.getStatus(),
+      );
+      return;
+    }
+
+    if (exception instanceof HttpException) {
+      const status = exception.getStatus();
+      const body = exception.getResponse();
+
+      httpAdapter.reply(
+        response,
+        typeof body === 'string' ? { error: body } : body,
+        status,
+      );
+      return;
+    }
+
+    this.logger.error(
+      exception instanceof Error ? exception.message : String(exception),
+      exception instanceof Error ? exception.stack : undefined,
+    );
+
+    httpAdapter.reply(
+      response,
+      { error: 'Internal server error' },
+      HttpStatus.INTERNAL_SERVER_ERROR,
+    );
+  }
+}

package/libs/common/src/index.ts

@@ -0,0 +1,15 @@
+export { DomainError } from './errors/domain.error';
+export { DomainExceptionFilter } from './filters/domain-exception.filter';
+export { LoggingInterceptor } from './interceptors/logging.interceptor';
+
+// Database
+export { DatabaseModule } from './database/database.module';
+export type { DatabaseModuleAsyncOptions } from './database/database.module';
+export { DATABASE_CONFIG } from './database/database.config';
+export type { DatabaseModuleConfig } from './database/database.config';
+export { DatabaseConnectionHolder } from './database/database-connection.holder';
+export type { DatabaseConnectionParams } from './database/database-connection.holder';
+export { DataSourceService } from './database/data-source.service';
+export { EmbeddedDatabaseService } from './database/embedded-database.service';
+export { FileStoreFactory } from './database/file-store.factory';
+export { FileStore } from './database/file-store';

package/libs/common/src/interceptors/logging.interceptor.ts

@@ -0,0 +1,60 @@
+import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  Logger,
+} from '@nestjs/common';
+import { Observable, tap } from 'rxjs';
+import { randomUUID } from 'node:crypto';
+
+const REQUEST_ID_HEADER = 'x-request-id';
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  private readonly logger = new Logger(LoggingInterceptor.name);
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+    const req = context.switchToHttp().getRequest();
+    const res = context.switchToHttp().getResponse();
+    const method: string = req.method;
+    const url: string = req.url;
+    const start = Date.now();
+
+    // Attach or reuse a request ID for tracing
+    const requestId: string = req.headers?.[REQUEST_ID_HEADER] ?? randomUUID();
+    if (res.header) {
+      res.header(REQUEST_ID_HEADER, requestId);
+    }
+
+    return next.handle().pipe(
+      tap({
+        next: () => {
+          const statusCode: number = res.statusCode;
+          const elapsed = Date.now() - start;
+          this.logger.log(
+            JSON.stringify({
+              requestId,
+              method,
+              url,
+              statusCode,
+              elapsed,
+            }),
+          );
+        },
+        error: (err) => {
+          const elapsed = Date.now() - start;
+          this.logger.warn(
+            JSON.stringify({
+              requestId,
+              method,
+              url,
+              error: err instanceof Error ? err.message : String(err),
+              elapsed,
+            }),
+          );
+        },
+      }),
+    );
+  }
+}

package/libs/common/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/libs/common",
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/libs/project-provider/src/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const REGISTRY_PROVIDER = 'REGISTRY_PROVIDER';
+export declare const EMPLOYEE_CODE_PROVIDER = 'EMPLOYEE_CODE_PROVIDER';
+export declare const KNOWLEDGE_BASE = 'KNOWLEDGE_BASE';
+export declare const INBOX_CLIENT = 'INBOX_CLIENT';
+export declare const AL_PARSER = 'AL_PARSER';
+export declare const REGISTRY_PATH = 'REGISTRY_PATH';
+export declare const INBOXES_PATH = 'INBOXES_PATH';

package/libs/project-provider/src/constants.js

@@ -0,0 +1,18 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.INBOXES_PATH =
+  exports.REGISTRY_PATH =
+  exports.AL_PARSER =
+  exports.INBOX_CLIENT =
+  exports.KNOWLEDGE_BASE =
+  exports.EMPLOYEE_CODE_PROVIDER =
+  exports.REGISTRY_PROVIDER =
+    void 0;
+exports.REGISTRY_PROVIDER = 'REGISTRY_PROVIDER';
+exports.EMPLOYEE_CODE_PROVIDER = 'EMPLOYEE_CODE_PROVIDER';
+exports.KNOWLEDGE_BASE = 'KNOWLEDGE_BASE';
+exports.INBOX_CLIENT = 'INBOX_CLIENT';
+exports.AL_PARSER = 'AL_PARSER';
+exports.REGISTRY_PATH = 'REGISTRY_PATH';
+exports.INBOXES_PATH = 'INBOXES_PATH';
+//# sourceMappingURL=constants.js.map

package/libs/project-provider/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,iBAAiB,GAAG,mBAAmB,CAAC;AACxC,QAAA,sBAAsB,GAAG,wBAAwB,CAAC;AAClD,QAAA,cAAc,GAAG,gBAAgB,CAAC;AAClC,QAAA,YAAY,GAAG,cAAc,CAAC;AAC9B,QAAA,SAAS,GAAG,WAAW,CAAC;AACxB,QAAA,aAAa,GAAG,eAAe,CAAC;AAChC,QAAA,YAAY,GAAG,cAAc,CAAC"}

package/libs/project-provider/src/constants.ts

@@ -0,0 +1,7 @@
+export const REGISTRY_PROVIDER = 'REGISTRY_PROVIDER';
+export const EMPLOYEE_CODE_PROVIDER = 'EMPLOYEE_CODE_PROVIDER';
+export const KNOWLEDGE_BASE = 'KNOWLEDGE_BASE';
+export const INBOX_CLIENT = 'INBOX_CLIENT';
+export const AL_PARSER = 'AL_PARSER';
+export const REGISTRY_PATH = 'REGISTRY_PATH';
+export const INBOXES_PATH = 'INBOXES_PATH';

package/libs/project-provider/src/errors/domain.error.d.ts

@@ -0,0 +1,4 @@
+export declare class DomainError extends Error {
+  readonly statusCode: number;
+  constructor(message: string, statusCode?: number);
+}

package/libs/project-provider/src/errors/domain.error.js

@@ -0,0 +1,13 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.DomainError = void 0;
+class DomainError extends Error {
+  statusCode;
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = this.constructor.name;
+  }
+}
+exports.DomainError = DomainError;
+//# sourceMappingURL=domain.error.js.map

package/libs/project-provider/src/errors/domain.error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.error.js","sourceRoot":"","sources":["domain.error.ts"],"names":[],"mappings":";;;AAAA,MAAa,WAAY,SAAQ,KAAK;IAGlB;IAFlB,YACE,OAAe,EACC,aAAqB,GAAG;QAExC,KAAK,CAAC,OAAO,CAAC,CAAC;QAFC,eAAU,GAAV,UAAU,CAAc;QAGxC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACpC,CAAC;CACF;AARD,kCAQC"}

package/libs/project-provider/src/errors/domain.error.ts

@@ -0,0 +1 @@
+export { DomainError } from '@app/common';

package/libs/project-provider/src/errors/employee-code.errors.d.ts

@@ -0,0 +1,13 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+export declare class EmployeeCodeError extends HttpException {
+  constructor(message: string, status?: HttpStatus);
+}
+export declare class ModuleNotFoundError extends EmployeeCodeError {
+  constructor(projectId: string, employeeId: string, moduleName: string);
+}
+export declare class PackageNotFoundError extends EmployeeCodeError {
+  constructor(projectId: string, employeeId: string);
+}
+export declare class ConfigNotFoundError extends EmployeeCodeError {
+  constructor(projectId: string, employeeId: string);
+}

package/libs/project-provider/src/errors/employee-code.errors.js

@@ -0,0 +1,42 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ConfigNotFoundError =
+  exports.PackageNotFoundError =
+  exports.ModuleNotFoundError =
+  exports.EmployeeCodeError =
+    void 0;
+const common_1 = require('@nestjs/common');
+class EmployeeCodeError extends common_1.HttpException {
+  constructor(message, status = common_1.HttpStatus.INTERNAL_SERVER_ERROR) {
+    super(message, status);
+  }
+}
+exports.EmployeeCodeError = EmployeeCodeError;
+class ModuleNotFoundError extends EmployeeCodeError {
+  constructor(projectId, employeeId, moduleName) {
+    super(
+      `Module not found: ${moduleName} in employee ${employeeId} of project ${projectId}`,
+      common_1.HttpStatus.NOT_FOUND,
+    );
+  }
+}
+exports.ModuleNotFoundError = ModuleNotFoundError;
+class PackageNotFoundError extends EmployeeCodeError {
+  constructor(projectId, employeeId) {
+    super(
+      `package.json not found for employee ${employeeId} in project ${projectId}`,
+      common_1.HttpStatus.NOT_FOUND,
+    );
+  }
+}
+exports.PackageNotFoundError = PackageNotFoundError;
+class ConfigNotFoundError extends EmployeeCodeError {
+  constructor(projectId, employeeId) {
+    super(
+      `config.al not found for employee ${employeeId} in project ${projectId}`,
+      common_1.HttpStatus.NOT_FOUND,
+    );
+  }
+}
+exports.ConfigNotFoundError = ConfigNotFoundError;
+//# sourceMappingURL=employee-code.errors.js.map

package/libs/project-provider/src/errors/employee-code.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"employee-code.errors.js","sourceRoot":"","sources":["employee-code.errors.ts"],"names":[],"mappings":";;;AAAA,2CAA2D;AAE3D,MAAa,iBAAkB,SAAQ,sBAAa;IAClD,YAAY,OAAe,EAAE,SAAqB,mBAAU,CAAC,qBAAqB;QAChF,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACzB,CAAC;CACF;AAJD,8CAIC;AAED,MAAa,mBAAoB,SAAQ,iBAAiB;IACxD,YAAY,SAAiB,EAAE,UAAkB,EAAE,UAAkB;QACnE,KAAK,CACH,qBAAqB,UAAU,gBAAgB,UAAU,eAAe,SAAS,EAAE,EACnF,mBAAU,CAAC,SAAS,CACrB,CAAC;IACJ,CAAC;CACF;AAPD,kDAOC;AAED,MAAa,oBAAqB,SAAQ,iBAAiB;IACzD,YAAY,SAAiB,EAAE,UAAkB;QAC/C,KAAK,CACH,uCAAuC,UAAU,eAAe,SAAS,EAAE,EAC3E,mBAAU,CAAC,SAAS,CACrB,CAAC;IACJ,CAAC;CACF;AAPD,oDAOC;AAED,MAAa,mBAAoB,SAAQ,iBAAiB;IACxD,YAAY,SAAiB,EAAE,UAAkB;QAC/C,KAAK,CACH,oCAAoC,UAAU,eAAe,SAAS,EAAE,EACxE,mBAAU,CAAC,SAAS,CACrB,CAAC;IACJ,CAAC;CACF;AAPD,kDAOC"}

package/libs/project-provider/src/errors/employee-code.errors.ts

@@ -0,0 +1,37 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export class EmployeeCodeError extends HttpException {
+  constructor(
+    message: string,
+    status: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,
+  ) {
+    super(message, status);
+  }
+}
+
+export class ModuleNotFoundError extends EmployeeCodeError {
+  constructor(projectId: string, employeeId: string, moduleName: string) {
+    super(
+      `Module not found: ${moduleName} in employee ${employeeId} of project ${projectId}`,
+      HttpStatus.NOT_FOUND,
+    );
+  }
+}
+
+export class PackageNotFoundError extends EmployeeCodeError {
+  constructor(projectId: string, employeeId: string) {
+    super(
+      `package.json not found for employee ${employeeId} in project ${projectId}`,
+      HttpStatus.NOT_FOUND,
+    );
+  }
+}
+
+export class ConfigNotFoundError extends EmployeeCodeError {
+  constructor(projectId: string, employeeId: string) {
+    super(
+      `config.al not found for employee ${employeeId} in project ${projectId}`,
+      HttpStatus.NOT_FOUND,
+    );
+  }
+}

package/libs/project-provider/src/errors/inbox.errors.d.ts

@@ -0,0 +1,13 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+export declare class InboxError extends HttpException {
+  constructor(message: string, status?: HttpStatus);
+}
+export declare class MessageNotFoundError extends InboxError {
+  constructor(inbox: string, messageId: string);
+}
+export declare class InvalidMessageOperationError extends InboxError {
+  constructor(message: string);
+}
+export declare class ContinuationFailedError extends InboxError {
+  constructor(message: string);
+}

package/libs/project-provider/src/errors/inbox.errors.js

@@ -0,0 +1,36 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ContinuationFailedError =
+  exports.InvalidMessageOperationError =
+  exports.MessageNotFoundError =
+  exports.InboxError =
+    void 0;
+const common_1 = require('@nestjs/common');
+class InboxError extends common_1.HttpException {
+  constructor(message, status = common_1.HttpStatus.INTERNAL_SERVER_ERROR) {
+    super(message, status);
+  }
+}
+exports.InboxError = InboxError;
+class MessageNotFoundError extends InboxError {
+  constructor(inbox, messageId) {
+    super(
+      `Message not found: ${messageId} in inbox ${inbox}`,
+      common_1.HttpStatus.NOT_FOUND,
+    );
+  }
+}
+exports.MessageNotFoundError = MessageNotFoundError;
+class InvalidMessageOperationError extends InboxError {
+  constructor(message) {
+    super(message, common_1.HttpStatus.BAD_REQUEST);
+  }
+}
+exports.InvalidMessageOperationError = InvalidMessageOperationError;
+class ContinuationFailedError extends InboxError {
+  constructor(message) {
+    super(message, common_1.HttpStatus.BAD_GATEWAY);
+  }
+}
+exports.ContinuationFailedError = ContinuationFailedError;
+//# sourceMappingURL=inbox.errors.js.map

package/libs/project-provider/src/errors/inbox.errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.errors.js","sourceRoot":"","sources":["inbox.errors.ts"],"names":[],"mappings":";;;AAAA,2CAA2D;AAE3D,MAAa,UAAW,SAAQ,sBAAa;IAC3C,YAAY,OAAe,EAAE,SAAqB,mBAAU,CAAC,qBAAqB;QAChF,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACzB,CAAC;CACF;AAJD,gCAIC;AAED,MAAa,oBAAqB,SAAQ,UAAU;IAClD,YAAY,KAAa,EAAE,SAAiB;QAC1C,KAAK,CACH,sBAAsB,SAAS,aAAa,KAAK,EAAE,EACnD,mBAAU,CAAC,SAAS,CACrB,CAAC;IACJ,CAAC;CACF;AAPD,oDAOC;AAED,MAAa,4BAA6B,SAAQ,UAAU;IAC1D,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,EAAE,mBAAU,CAAC,WAAW,CAAC,CAAC;IACzC,CAAC;CACF;AAJD,oEAIC;AAED,MAAa,uBAAwB,SAAQ,UAAU;IACrD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,EAAE,mBAAU,CAAC,WAAW,CAAC,CAAC;IACzC,CAAC;CACF;AAJD,0DAIC"}

package/libs/project-provider/src/errors/inbox.errors.ts

@@ -0,0 +1,31 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+export class InboxError extends HttpException {
+  constructor(
+    message: string,
+    status: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,
+  ) {
+    super(message, status);
+  }
+}
+
+export class MessageNotFoundError extends InboxError {
+  constructor(inbox: string, messageId: string) {
+    super(
+      `Message not found: ${messageId} in inbox ${inbox}`,
+      HttpStatus.NOT_FOUND,
+    );
+  }
+}
+
+export class InvalidMessageOperationError extends InboxError {
+  constructor(message: string) {
+    super(message, HttpStatus.BAD_REQUEST);
+  }
+}
+
+export class ContinuationFailedError extends InboxError {
+  constructor(message: string) {
+    super(message, HttpStatus.BAD_GATEWAY);
+  }
+}

package/libs/project-provider/src/errors/registry.errors.d.ts

@@ -0,0 +1,16 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+export declare class RegistryError extends HttpException {
+  constructor(message: string, status?: HttpStatus);
+}
+export declare class ProjectNotFoundError extends RegistryError {
+  constructor(projectId: string);
+}
+export declare class ProjectAlreadyExistsError extends RegistryError {
+  constructor(projectId: string);
+}
+export declare class EmployeeNotFoundError extends RegistryError {
+  constructor(projectId: string, employeeId: string);
+}
+export declare class EmployeeAlreadyExistsError extends RegistryError {
+  constructor(projectId: string, employeeId: string);
+}

package/libs/project-provider/src/errors/registry.errors.js

@@ -0,0 +1,46 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.EmployeeAlreadyExistsError =
+  exports.EmployeeNotFoundError =
+  exports.ProjectAlreadyExistsError =
+  exports.ProjectNotFoundError =
+  exports.RegistryError =
+    void 0;
+const common_1 = require('@nestjs/common');
+class RegistryError extends common_1.HttpException {
+  constructor(message, status = common_1.HttpStatus.INTERNAL_SERVER_ERROR) {
+    super(message, status);
+  }
+}
+exports.RegistryError = RegistryError;
+class ProjectNotFoundError extends RegistryError {
+  constructor(projectId) {
+    super(`Project not found: ${projectId}`, common_1.HttpStatus.NOT_FOUND);
+  }
+}
+exports.ProjectNotFoundError = ProjectNotFoundError;
+class ProjectAlreadyExistsError extends RegistryError {
+  constructor(projectId) {
+    super(`Project already exists: ${projectId}`, common_1.HttpStatus.CONFLICT);
+  }
+}
+exports.ProjectAlreadyExistsError = ProjectAlreadyExistsError;
+class EmployeeNotFoundError extends RegistryError {
+  constructor(projectId, employeeId) {
+    super(
+      `Employee not found: ${employeeId} in project ${projectId}`,
+      common_1.HttpStatus.NOT_FOUND,
+    );
+  }
+}
+exports.EmployeeNotFoundError = EmployeeNotFoundError;
+class EmployeeAlreadyExistsError extends RegistryError {
+  constructor(projectId, employeeId) {
+    super(
+      `Employee already exists: ${employeeId} in project ${projectId}`,
+      common_1.HttpStatus.CONFLICT,
+    );
+  }
+}
+exports.EmployeeAlreadyExistsError = EmployeeAlreadyExistsError;
+//# sourceMappingURL=registry.errors.js.map