@tstdl/base 0.93.76 → 0.93.78

package/authentication/server/schemas.js

@@ -1,5 +1,11 @@
 import { databaseSchema } from '../../orm/server/index.js';
-import { AuthenticationCredentials, AuthenticationSession } from '../models/index.js';
+import { AuthenticationCredentials, AuthenticationSession, ServiceAccount, Subject, SubjectType, SystemAccount, User, UserStatus } from '../models/index.js';
 export const authenticationSchema = databaseSchema('authentication');
+export const subjectType = authenticationSchema.getEnum(SubjectType);
+export const userStatus = authenticationSchema.getEnum(UserStatus);
 export const authenticationCredentials = authenticationSchema.getTable(AuthenticationCredentials);
 export const authenticationSession = authenticationSchema.getTable(AuthenticationSession);
+export const serviceAccount = authenticationSchema.getTable(ServiceAccount);
+export const subject = authenticationSchema.getTable(Subject);
+export const systemAccount = authenticationSchema.getTable(SystemAccount);
+export const user = authenticationSchema.getTable(User);

package/authentication/server/subject.service.d.ts

@@ -0,0 +1,6 @@
+import { Subject, SystemAccount } from '../models/index.js';
+export declare class SubjectService {
+    readonly subjectRepository: import("../../orm/server/index.js").EntityRepository<Subject>;
+    readonly systemAccountRepository: import("../../orm/server/index.js").EntityRepository<SystemAccount>;
+    getSystemAccountSubject(tenantId: string, identifier: string): Promise<Subject>;
+}

package/authentication/server/subject.service.js

@@ -0,0 +1,44 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Singleton } from '../../injector/index.js';
+import { injectRepository } from '../../orm/server/index.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { Subject, SubjectType, SystemAccount } from '../models/index.js';
+let SubjectService = class SubjectService {
+    subjectRepository = injectRepository(Subject);
+    systemAccountRepository = injectRepository(SystemAccount);
+    async getSystemAccountSubject(tenantId, identifier) {
+        return await this.subjectRepository.transaction(async (tx) => {
+            let systemAccount = await this.systemAccountRepository.withTransaction(tx).tryLoadByQuery({
+                tenantId,
+                identifier,
+            });
+            if (isUndefined(systemAccount)) {
+                systemAccount = await this.systemAccountRepository.withTransaction(tx).insert({
+                    tenantId,
+                    identifier,
+                });
+                return await this.subjectRepository.withTransaction(tx).insert({
+                    type: SubjectType.System,
+                    tenantId,
+                    systemAccountId: systemAccount.id,
+                    displayName: `System: ${identifier}`,
+                    userId: null,
+                    serviceAccountId: null,
+                });
+            }
+            return await this.subjectRepository.withTransaction(tx).loadByQuery({
+                tenantId,
+                systemAccountId: systemAccount.id,
+            });
+        });
+    }
+};
+SubjectService = __decorate([
+    Singleton()
+], SubjectService);
+export { SubjectService };

package/circuit-breaker/circuit-breaker.d.ts

@@ -0,0 +1,32 @@
+import { type EnumType } from '../enumeration/enumeration.js';
+import { resolveArgumentType, type Resolvable } from '../injector/interfaces.js';
+export declare const CircuitBreakerState: {
+    readonly Closed: "closed";
+    readonly Open: "open";
+    readonly HalfOpen: "half-open";
+};
+export type CircuitBreakerState = EnumType<typeof CircuitBreakerState>;
+export interface CircuitBreakerConfig {
+    threshold: number;
+    resetTimeout: number;
+}
+export interface CircuitBreakerCheckResult {
+    allowed: boolean;
+    state: CircuitBreakerState;
+    isProbe?: boolean;
+}
+export type CircuitBreakerArgument = string | (CircuitBreakerConfig & {
+    key: string;
+});
+export declare abstract class CircuitBreaker implements Resolvable<CircuitBreakerArgument> {
+    readonly [resolveArgumentType]: CircuitBreakerArgument;
+    /**
+     * Checks if execution is allowed.
+     * Transitions from Open to Half-Open automatically if timeout passed.
+     */
+    abstract check(): Promise<CircuitBreakerCheckResult>;
+    /** Records a success, resetting the breaker to Closed. */
+    abstract recordSuccess(): Promise<void>;
+    /** Records a failure, potentially tripping the breaker to Open. */
+    abstract recordFailure(): Promise<void>;
+}

package/circuit-breaker/circuit-breaker.js

@@ -0,0 +1,9 @@
+import { defineEnum } from '../enumeration/enumeration.js';
+import { resolveArgumentType } from '../injector/interfaces.js';
+export const CircuitBreakerState = defineEnum('CircuitBreakerState', {
+    Closed: 'closed',
+    Open: 'open',
+    HalfOpen: 'half-open',
+});
+export class CircuitBreaker {
+}

package/circuit-breaker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './circuit-breaker.js';
+export * from './provider.js';

package/circuit-breaker/index.js

@@ -0,0 +1,2 @@
+export * from './circuit-breaker.js';
+export * from './provider.js';

package/circuit-breaker/postgres/circuit-breaker.d.ts

@@ -0,0 +1,7 @@
+import { CircuitBreaker, type CircuitBreakerCheckResult } from '../circuit-breaker.js';
+export declare class PostgresCircuitBreakerService extends CircuitBreaker {
+    #private;
+    check(): Promise<CircuitBreakerCheckResult>;
+    recordSuccess(): Promise<void>;
+    recordFailure(): Promise<void>;
+}

package/circuit-breaker/postgres/circuit-breaker.js

@@ -0,0 +1,78 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { sql } from 'drizzle-orm';
+import { injectArgument, provide, Singleton } from '../../injector/index.js';
+import { interval, TRANSACTION_TIMESTAMP } from '../../orm/index.js';
+import { DatabaseConfig, injectRepository } from '../../orm/server/index.js';
+import { currentTimestamp } from '../../utils/date-time.js';
+import { isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { millisecondsPerSecond } from '../../utils/units.js';
+import { CircuitBreaker, CircuitBreakerState } from '../circuit-breaker.js';
+import { PostgresCircuitBreaker } from './model.js';
+import { PostgresCircuitBreakerModuleConfig } from './module.js';
+let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends CircuitBreaker {
+    #repository = injectRepository(PostgresCircuitBreaker);
+    #arg = injectArgument(this);
+    #key = isString(this.#arg) ? this.#arg : this.#arg.key;
+    #threshold = (isString(this.#arg) ? undefined : this.#arg.threshold) ?? 5;
+    #resetTimeout = (isString(this.#arg) ? undefined : this.#arg.resetTimeout) ?? 30 * millisecondsPerSecond;
+    async check() {
+        return await this.#repository.transaction(async (tx) => {
+            const breaker = await this.#repository.withTransaction(tx).tryLoadByQuery({ key: this.#key });
+            if (isUndefined(breaker) || breaker.state === CircuitBreakerState.Closed) {
+                return { allowed: true, state: CircuitBreakerState.Closed };
+            }
+            if (breaker.state === CircuitBreakerState.HalfOpen) {
+                return { allowed: true, state: CircuitBreakerState.HalfOpen, isProbe: false };
+            }
+            // State is Open
+            if (currentTimestamp() < (breaker.resetTimestamp ?? 0)) {
+                return { allowed: false, state: CircuitBreakerState.Open };
+            }
+            // Atomic transition from Open -> HalfOpen (The Probe)
+            const updated = await this.#repository.withTransaction(tx).tryUpdateByQuery({ key: this.#key, state: CircuitBreakerState.Open }, { state: CircuitBreakerState.HalfOpen });
+            const isProbe = isDefined(updated);
+            return { allowed: isProbe, state: isProbe ? CircuitBreakerState.HalfOpen : CircuitBreakerState.Open, isProbe };
+        });
+    }
+    async recordSuccess() {
+        await this.#repository.tryDeleteByQuery({ key: this.#key });
+    }
+    async recordFailure() {
+        const table = this.#repository.table;
+        const initialTrip = 1 >= this.#threshold;
+        const initialState = initialTrip ? CircuitBreakerState.Open : CircuitBreakerState.Closed;
+        const initialResetTimestamp = initialTrip
+            ? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}`
+            : null;
+        await this.#repository.upsert(['key'], {
+            key: this.#key,
+            state: initialState,
+            failureCount: 1,
+            resetTimestamp: initialResetTimestamp,
+        }, {
+            failureCount: sql `${table.failureCount} + 1`,
+            state: sql `CASE
+          WHEN ${table.failureCount} + 1 >= ${this.#threshold} THEN ${CircuitBreakerState.Open}
+          ELSE ${table.state}
+        END`,
+            resetTimestamp: sql `CASE
+          WHEN ${table.failureCount} + 1 >= ${this.#threshold} THEN ${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
+          ELSE ${table.resetTimestamp}
+        END`,
+        });
+    }
+};
+PostgresCircuitBreakerService = __decorate([
+    Singleton({
+        argumentIdentityProvider: (arg) => isString(arg) ? arg : arg.key,
+        providers: [
+            provide(DatabaseConfig, { useFactory: (_, context) => context.resolve(PostgresCircuitBreakerModuleConfig).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }) }),
+        ],
+    })
+], PostgresCircuitBreakerService);
+export { PostgresCircuitBreakerService };

package/circuit-breaker/postgres/drizzle/0000_hard_shocker.sql

@@ -0,0 +1,9 @@
+CREATE TYPE "circuit_breaker"."circuit_breaker_state" AS ENUM('closed', 'open', 'half-open');--> statement-breakpoint
+CREATE TABLE "circuit_breaker"."circuit_breaker" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"key" text NOT NULL,
+	"state" "circuit_breaker"."circuit_breaker_state" NOT NULL,
+	"failure_count" integer NOT NULL,
+	"reset_timestamp" timestamp with time zone,
+	CONSTRAINT "circuit_breaker_key_unique" UNIQUE("key")
+);

package/circuit-breaker/postgres/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,82 @@
+{
+  "id": "cc140886-299f-4337-b208-50a976c703f3",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "circuit_breaker.circuit_breaker": {
+      "name": "circuit_breaker",
+      "schema": "circuit_breaker",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "state": {
+          "name": "state",
+          "type": "circuit_breaker_state",
+          "typeSchema": "circuit_breaker",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "failure_count": {
+          "name": "failure_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reset_timestamp": {
+          "name": "reset_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "circuit_breaker_key_unique": {
+          "name": "circuit_breaker_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "key"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "circuit_breaker.circuit_breaker_state": {
+      "name": "circuit_breaker_state",
+      "schema": "circuit_breaker",
+      "values": [
+        "closed",
+        "open",
+        "half-open"
+      ]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/circuit-breaker/postgres/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1767729693157,
+      "tag": "0000_hard_shocker",
+      "breakpoints": true
+    }
+  ]
+}

package/circuit-breaker/postgres/drizzle.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;

package/circuit-breaker/postgres/drizzle.config.js

@@ -0,0 +1,11 @@
+import { relative, resolve } from 'node:path';
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    dialect: 'postgresql',
+    out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
+    schema: resolve(__dirname, './schemas.js'),
+    migrations: {
+        schema: 'circuit_breaker',
+        table: '_migrations',
+    },
+});

package/circuit-breaker/postgres/index.d.ts

@@ -0,0 +1,5 @@
+export * from './circuit-breaker.js';
+export * from './model.js';
+export * from './module.js';
+export * from './provider.js';
+export * from './schemas.js';

package/circuit-breaker/postgres/index.js

@@ -0,0 +1,5 @@
+export * from './circuit-breaker.js';
+export * from './model.js';
+export * from './module.js';
+export * from './provider.js';
+export * from './schemas.js';

package/circuit-breaker/postgres/model.d.ts

@@ -0,0 +1,9 @@
+import { BaseEntity, type Timestamp } from '../../orm/index.js';
+import { CircuitBreakerState } from '../circuit-breaker.js';
+export declare class PostgresCircuitBreaker extends BaseEntity {
+    static readonly entityName = "CircuitBreaker";
+    key: string;
+    state: CircuitBreakerState;
+    failureCount: number;
+    resetTimestamp: Timestamp | null;
+}

package/circuit-breaker/postgres/model.js

@@ -0,0 +1,40 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseEntity, Table, TimestampProperty, Unique } from '../../orm/index.js';
+import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
+import { CircuitBreakerState } from '../circuit-breaker.js';
+let PostgresCircuitBreaker = class PostgresCircuitBreaker extends BaseEntity {
+    static entityName = 'CircuitBreaker';
+    key;
+    state;
+    failureCount;
+    resetTimestamp;
+};
+__decorate([
+    StringProperty(),
+    Unique(),
+    __metadata("design:type", String)
+], PostgresCircuitBreaker.prototype, "key", void 0);
+__decorate([
+    Enumeration(CircuitBreakerState),
+    __metadata("design:type", String)
+], PostgresCircuitBreaker.prototype, "state", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], PostgresCircuitBreaker.prototype, "failureCount", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], PostgresCircuitBreaker.prototype, "resetTimestamp", void 0);
+PostgresCircuitBreaker = __decorate([
+    Table('circuit_breaker', { schema: 'circuit_breaker' })
+], PostgresCircuitBreaker);
+export { PostgresCircuitBreaker };

package/circuit-breaker/postgres/module.d.ts

@@ -0,0 +1,6 @@
+import { type DatabaseConfig } from '../../orm/server/index.js';
+export declare class PostgresCircuitBreakerModuleConfig {
+    database?: DatabaseConfig;
+}
+export declare function configurePostgresCircuitBreaker(config?: PostgresCircuitBreakerModuleConfig, register?: boolean): void;
+export declare function migratePostgresCircuitBreaker(): Promise<void>;

package/circuit-breaker/postgres/module.js

@@ -0,0 +1,25 @@
+import { inject, Injector } from '../../injector/index.js';
+import { Database, migrate } from '../../orm/server/index.js';
+import { CircuitBreaker } from '../circuit-breaker.js';
+import { CircuitBreakerProvider } from '../provider.js';
+import { PostgresCircuitBreakerService } from './circuit-breaker.js';
+import { PostgresCircuitBreakerProvider } from './provider.js';
+export class PostgresCircuitBreakerModuleConfig {
+    database;
+}
+export function configurePostgresCircuitBreaker(config, register = true) {
+    Injector.register(PostgresCircuitBreakerModuleConfig, { useValue: config });
+    if (register) {
+        Injector.registerSingleton(CircuitBreakerProvider, { useToken: PostgresCircuitBreakerProvider });
+        Injector.registerSingleton(CircuitBreaker, { useToken: PostgresCircuitBreakerService });
+    }
+}
+export async function migratePostgresCircuitBreaker() {
+    const connection = inject(PostgresCircuitBreakerModuleConfig, undefined, { optional: true })?.database?.connection;
+    const database = inject(Database, connection);
+    await migrate(database, {
+        migrationsSchema: 'circuit_breaker',
+        migrationsTable: '_migrations',
+        migrationsFolder: import.meta.resolve('./drizzle'),
+    });
+}

package/circuit-breaker/postgres/provider.d.ts

@@ -0,0 +1,6 @@
+import type { CircuitBreaker, CircuitBreakerConfig } from '../circuit-breaker.js';
+import { CircuitBreakerProvider } from '../provider.js';
+export declare class PostgresCircuitBreakerProvider extends CircuitBreakerProvider {
+    #private;
+    provide(key: string, config?: CircuitBreakerConfig): CircuitBreaker;
+}

package/circuit-breaker/postgres/provider.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { inject, Singleton } from '../../injector/index.js';
+import { Injector } from '../../injector/injector.js';
+import { CircuitBreakerProvider } from '../provider.js';
+import { PostgresCircuitBreakerService } from './circuit-breaker.js';
+let PostgresCircuitBreakerProvider = class PostgresCircuitBreakerProvider extends CircuitBreakerProvider {
+    #injector = inject(Injector);
+    provide(key, config) {
+        const argument = config ? { key, ...config } : key;
+        return this.#injector.resolve(PostgresCircuitBreakerService, argument);
+    }
+};
+PostgresCircuitBreakerProvider = __decorate([
+    Singleton()
+], PostgresCircuitBreakerProvider);
+export { PostgresCircuitBreakerProvider };

package/circuit-breaker/postgres/schemas.d.ts

@@ -0,0 +1,8 @@
+import { PostgresCircuitBreaker } from './model.js';
+export declare const circuitBreakerSchema: import("../../orm/server/index.js").DatabaseSchema<"circuit_breaker">;
+export declare const circuitBreakerState: import("../../orm/enums.js").PgEnumFromEnumeration<{
+    readonly Closed: "closed";
+    readonly Open: "open";
+    readonly HalfOpen: "half-open";
+}>;
+export declare const circuitBreaker: import("../../orm/server/types.js").PgTableFromType<typeof PostgresCircuitBreaker, "circuit_breaker">;

package/circuit-breaker/postgres/schemas.js

@@ -0,0 +1,6 @@
+import { databaseSchema } from '../../orm/server/index.js';
+import { CircuitBreakerState } from '../circuit-breaker.js';
+import { PostgresCircuitBreaker } from './model.js';
+export const circuitBreakerSchema = databaseSchema('circuit_breaker');
+export const circuitBreakerState = circuitBreakerSchema.getEnum(CircuitBreakerState);
+export const circuitBreaker = circuitBreakerSchema.getTable(PostgresCircuitBreaker);

package/circuit-breaker/provider.d.ts

@@ -0,0 +1,4 @@
+import type { CircuitBreaker, CircuitBreakerConfig } from './circuit-breaker.js';
+export declare abstract class CircuitBreakerProvider {
+    abstract provide(key: string, config?: CircuitBreakerConfig): CircuitBreaker;
+}

package/circuit-breaker/provider.js

@@ -0,0 +1,2 @@
+export class CircuitBreakerProvider {
+}

package/circuit-breaker/tests/circuit-breaker.test.js

@@ -0,0 +1,113 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { CircuitBreakerState } from '../../circuit-breaker/index.js';
+import { CircuitBreakerProvider } from '../../circuit-breaker/provider.js';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { configureOrm } from '../../orm/server/index.js';
+import * as configParser from '../../utils/config-parser.js';
+import { timeout } from '../../utils/timing.js';
+import { configurePostgresCircuitBreaker, migratePostgresCircuitBreaker } from '../postgres/module.js';
+async function setupIntegrationTest() {
+    const injector = new Injector('TestInjector');
+    const dbConfig = {
+        host: configParser.string('DATABASE_HOST', '127.0.0.1'),
+        port: configParser.positiveInteger('DATABASE_PORT', 5432),
+        user: configParser.string('DATABASE_USER', 'tstdl'),
+        password: configParser.string('DATABASE_PASS', 'wf7rq6glrk5jykne'),
+        database: configParser.string('DATABASE_NAME', 'tstdl'),
+    };
+    configureOrm({
+        repositoryConfig: { schema: 'test' },
+        connection: dbConfig,
+    });
+    configurePostgresCircuitBreaker({ database: { connection: dbConfig } });
+    await runInInjectionContext(injector, migratePostgresCircuitBreaker);
+    return injector;
+}
+describe('Circuit Breaker (Standalone) Tests', () => {
+    let injector;
+    let provider;
+    beforeAll(async () => {
+        injector = await setupIntegrationTest();
+        provider = injector.resolve(CircuitBreakerProvider);
+    });
+    afterAll(async () => {
+        await injector.dispose();
+    });
+    it('should start in Closed state', async () => {
+        const breaker = provider.provide(`cb-init-${Date.now()}`, { threshold: 2, resetTimeout: 1000 });
+        const result = await breaker.check();
+        expect(result.allowed).toBe(true);
+        expect(result.state).toBe(CircuitBreakerState.Closed);
+    });
+    it('should trip to Open after threshold failures', async () => {
+        const breaker = provider.provide(`cb-trip-${Date.now()}`, { threshold: 2, resetTimeout: 1000 });
+        // 1. First Failure
+        await breaker.recordFailure();
+        let result = await breaker.check();
+        expect(result.state).toBe(CircuitBreakerState.Closed);
+        // 2. Second Failure (Threshold Reached)
+        await breaker.recordFailure();
+        result = await breaker.check();
+        expect(result.allowed).toBe(false);
+        expect(result.state).toBe(CircuitBreakerState.Open);
+    });
+    it('should reset to Closed on success', async () => {
+        const breaker = provider.provide(`cb-reset-${Date.now()}`, { threshold: 2, resetTimeout: 1000 });
+        // Trip it
+        await breaker.recordFailure();
+        await breaker.recordFailure();
+        expect((await breaker.check()).state).toBe(CircuitBreakerState.Open);
+        // Record Success
+        await breaker.recordSuccess();
+        const result = await breaker.check();
+        expect(result.allowed).toBe(true);
+        expect(result.state).toBe(CircuitBreakerState.Closed);
+    });
+    it('should transition to Half-Open (Probe) after timeout', async () => {
+        const timeoutMs = 200;
+        const breaker = provider.provide(`cb-probe-${Date.now()}`, { threshold: 1, resetTimeout: timeoutMs });
+        // Trip it
+        await breaker.recordFailure();
+        expect((await breaker.check()).state).toBe(CircuitBreakerState.Open);
+        // Wait for timeout
+        await timeout(timeoutMs + 50);
+        // First check should be the Probe
+        const probe = await breaker.check();
+        expect(probe.allowed).toBe(true);
+        expect(probe.state).toBe(CircuitBreakerState.HalfOpen);
+        expect(probe.isProbe).toBe(true);
+        // Subsequent check should be denied (Half-Open wait)
+        const subsequent = await breaker.check();
+        expect(subsequent.allowed).toBe(true); // check() allows HalfOpen, but queue logic restricts it.
+        // Wait, let's verify PostgresCircuitBreakerService logic:
+        // if (breaker.state === CircuitBreakerState.HalfOpen) return { allowed: true, state: CircuitBreakerState.HalfOpen, isProbe: false };
+        expect(subsequent.state).toBe(CircuitBreakerState.HalfOpen);
+        expect(subsequent.isProbe).toBe(false);
+    });
+    it('should close if Probe succeeds', async () => {
+        const timeoutMs = 100;
+        const breaker = provider.provide(`cb-probe-success-${Date.now()}`, { threshold: 1, resetTimeout: timeoutMs });
+        // Trip and Probe
+        await breaker.recordFailure();
+        await timeout(timeoutMs + 50);
+        await breaker.check(); // Probe triggered
+        // Probe succeeds
+        await breaker.recordSuccess();
+        const result = await breaker.check();
+        expect(result.state).toBe(CircuitBreakerState.Closed);
+    });
+    it('should reopen if Probe fails', async () => {
+        const timeoutMs = 100;
+        const breaker = provider.provide(`cb-probe-fail-${Date.now()}`, { threshold: 1, resetTimeout: timeoutMs });
+        // Trip and Probe
+        await breaker.recordFailure();
+        await timeout(timeoutMs + 50);
+        await breaker.check(); // Probe triggered (State: HalfOpen)
+        // Probe fails
+        await breaker.recordFailure();
+        // Should be Open again
+        const result = await breaker.check();
+        expect(result.allowed).toBe(false);
+        expect(result.state).toBe(CircuitBreakerState.Open);
+    });
+});

package/document-management/models/document.model.d.ts

@@ -21,5 +21,4 @@ export declare class Document extends TenantEntity {
     mimeType: string;
     hash: string;
     size: number;
-    createUserId: Uuid | null;
 }

package/document-management/models/document.model.js

@@ -31,7 +31,6 @@ let Document = class Document extends TenantEntity {
     mimeType;
     hash;
     size;
-    createUserId;
 };
 __decorate([
     UuidProperty({ nullable: true }),
@@ -82,10 +81,6 @@ __decorate([
     Integer(),
     __metadata("design:type", Number)
 ], Document.prototype, "size", void 0);
-__decorate([
-    UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], Document.prototype, "createUserId", void 0);
 Document = __decorate([
     DocumentManagementTable(),
     Unique(['tenantId', 'id'])

package/document-management/server/api/document-management.api.js

@@ -155,8 +155,7 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
                 }
             }
         }
-        const actionUserId = await this.#authorizationService.getSubject(token);
-        return await this.#documentService.create(tenantId, createParameters, { uploadId, uploadKey: subject }, { createUserId: actionUserId });
+        return await this.#documentService.create(tenantId, createParameters, { uploadId, uploadKey: subject });
     }
     async createDocumentRequestsTemplate(context) {
         const token = await context.getToken();

package/document-management/server/drizzle/0002_round_warbird.sql

@@ -0,0 +1 @@
+ALTER TABLE "document_management"."document" DROP COLUMN "create_user_id";