@cullet/erp-core 1.0.2 → 1.0.3

package/src/core/application/temporal/temporal-context.ts

@@ -2,40 +2,40 @@ import { makeImmutable } from "../../shared/immutable";
 import { assertValidDate } from "../../shared/temporal-guards";
 
 interface TemporalContext {
-  readonly asOf: Date;
-  readonly requestedAt: Date;
+    readonly asOf: Date;
+    readonly requestedAt: Date;
 }
 
 interface CreateTemporalContextInput {
-  readonly asOf?: Date;
-  readonly requestedAt?: Date;
+    readonly asOf?: Date;
+    readonly requestedAt?: Date;
 }
 
 function assertTemporalContext(
-  temporalContext: TemporalContext,
-  fieldName: string = "temporalContext",
+    temporalContext: TemporalContext,
+    fieldName: string = "temporalContext",
 ): void {
-  assertValidDate(`${fieldName}.asOf`, temporalContext.asOf);
-  assertValidDate(`${fieldName}.requestedAt`, temporalContext.requestedAt);
+    assertValidDate(`${fieldName}.asOf`, temporalContext.asOf);
+    assertValidDate(`${fieldName}.requestedAt`, temporalContext.requestedAt);
 }
 
 function createTemporalContext(
-  input: CreateTemporalContextInput = {},
+    input: CreateTemporalContextInput = {},
 ): TemporalContext {
-  const requestedAt = input.requestedAt ?? new Date();
-  const asOf = input.asOf ?? requestedAt;
+    const requestedAt = input.requestedAt ?? new Date();
+    const asOf = input.asOf ?? requestedAt;
 
-  assertTemporalContext({ asOf, requestedAt });
+    assertTemporalContext({ asOf, requestedAt });
 
-  return makeImmutable({
-    asOf,
-    requestedAt,
-  });
+    return makeImmutable({
+        asOf,
+        requestedAt,
+    });
 }
 
 export {
-  assertTemporalContext,
-  createTemporalContext,
-  type CreateTemporalContextInput,
-  type TemporalContext,
+    assertTemporalContext,
+    createTemporalContext,
+    type CreateTemporalContextInput,
+    type TemporalContext,
 };

package/src/core/application/temporal/temporal-use-case.ts

@@ -3,38 +3,38 @@ import type { ContextSeed } from "../../policies";
 import type { Result } from "../../result/result";
 
 import {
-  createTemporalContext,
-  type TemporalContext,
+    createTemporalContext,
+    type TemporalContext,
 } from "./temporal-context";
 
 interface TemporalUseCaseInput {
-  readonly temporalContext?: TemporalContext;
+    readonly temporalContext?: TemporalContext;
 }
 
 type TemporalizedContextSeed<TSeed extends ContextSeed> = TSeed;
 
 abstract class TemporalUseCase<
-  Input extends object,
-  Output extends Result<unknown, unknown>,
+    Input extends object,
+    Output extends Result<unknown, unknown>,
 > extends UseCase<Input & TemporalUseCaseInput, Output> {
-  protected resolveTemporalContext(
-    input: Input & TemporalUseCaseInput,
-  ): TemporalContext {
-    return createTemporalContext(input.temporalContext);
-  }
+    protected resolveTemporalContext(
+        input: Input & TemporalUseCaseInput,
+    ): TemporalContext {
+        return createTemporalContext(input.temporalContext);
+    }
 
-  protected buildPolicySeed<TSeed extends ContextSeed>(
-    seed: TSeed,
-    temporalContext: TemporalContext,
-  ): TemporalizedContextSeed<TSeed> {
-    return Object.freeze({
-      ...seed,
-      fields: {
-        ...seed.fields,
-        now: new Date(temporalContext.requestedAt.getTime()),
-      },
-    }) as TSeed;
-  }
+    protected buildPolicySeed<TSeed extends ContextSeed>(
+        seed: TSeed,
+        temporalContext: TemporalContext,
+    ): TemporalizedContextSeed<TSeed> {
+        return Object.freeze({
+            ...seed,
+            fields: {
+                ...seed.fields,
+                now: new Date(temporalContext.requestedAt.getTime()),
+            },
+        }) as TSeed;
+    }
 }
 
 export type { TemporalizedContextSeed, TemporalUseCaseInput };

package/src/core/application/use-case.ts

@@ -5,20 +5,20 @@ type MaybePromise<T> = T | Promise<T>;
 
 @version("1.0")
 abstract class UseCase<
-  Input = void,
-  Output extends Result<unknown, unknown> = Result<void, never>,
+    Input = void,
+    Output extends Result<unknown, unknown> = Result<void, never>,
 > {
-  public static readonly CONTRACT_VERSION: ContractVersion;
+    public static readonly CONTRACT_VERSION: ContractVersion;
 
-  public get contractVersion(): ContractVersion {
-    return UseCase.CONTRACT_VERSION;
-  }
+    public get contractVersion(): ContractVersion {
+        return UseCase.CONTRACT_VERSION;
+    }
 
-  public async run(input: Input): Promise<Output> {
-    return await this.execute(input);
-  }
+    public async run(input: Input): Promise<Output> {
+        return await this.execute(input);
+    }
 
-  protected abstract execute(input: Input): MaybePromise<Output>;
+    protected abstract execute(input: Input): MaybePromise<Output>;
 }
 
 export { type MaybePromise, UseCase };

package/src/core/config/core-config.instance.ts

@@ -10,5 +10,5 @@ import { SilentPolicyReporter } from "./silent-policy-reporter";
  * `coreConfig.configure({ observability: { reporter } })`.
  */
 export const coreConfig = new CoreConfig({
-  observability: { reporter: new SilentPolicyReporter() },
+    observability: { reporter: new SilentPolicyReporter() },
 });

package/src/core/config/core-config.ts

@@ -1,27 +1,27 @@
 import type {
-  ConditionEvaluationOptions,
-  ConditionEvaluatorReporter,
+    ConditionEvaluationOptions,
+    ConditionEvaluatorReporter,
 } from "../policies/engines/condition-evaluator-reporter";
 import type { PolicyEvent, PolicyReporter } from "./policy-reporter";
 import { SilentPolicyReporter } from "./silent-policy-reporter";
 
 export interface CoreObservabilityConfig {
-  readonly reporter?: PolicyReporter;
+    readonly reporter?: PolicyReporter;
 }
 
 export interface CoreConfigOptions {
-  readonly observability?: CoreObservabilityConfig;
+    readonly observability?: CoreObservabilityConfig;
 }
 
 function reportSafely(
-  policyReporter: PolicyReporter,
-  event: PolicyEvent,
+    policyReporter: PolicyReporter,
+    event: PolicyEvent,
 ): void {
-  try {
-    policyReporter.report(event);
-  } catch {
-    // Falhas de telemetria nao podem interromper o fluxo de dominio.
-  }
+    try {
+        policyReporter.report(event);
+    } catch {
+        // Falhas de telemetria nao podem interromper o fluxo de dominio.
+    }
 }
 
 /**
@@ -29,59 +29,59 @@ function reportSafely(
  * concretas de logging, tracing ou report.
  */
 export class CoreConfig {
-  readonly #initialReporter: PolicyReporter;
-  #currentReporter: PolicyReporter;
+    readonly #initialReporter: PolicyReporter;
+    #currentReporter: PolicyReporter;
 
-  constructor(options: CoreConfigOptions = {}) {
-    const reporter =
-      options.observability?.reporter ?? new SilentPolicyReporter();
-    this.#initialReporter = reporter;
-    this.#currentReporter = reporter;
-  }
+    constructor(options: CoreConfigOptions = {}) {
+        const reporter =
+            options.observability?.reporter ?? new SilentPolicyReporter();
+        this.#initialReporter = reporter;
+        this.#currentReporter = reporter;
+    }
 
-  configure(options: CoreConfigOptions): this {
-    const reporter = options.observability?.reporter;
-    if (reporter) {
-      this.#currentReporter = reporter;
+    configure(options: CoreConfigOptions): this {
+        const reporter = options.observability?.reporter;
+        if (reporter) {
+            this.#currentReporter = reporter;
+        }
+        return this;
     }
-    return this;
-  }
 
-  // Restores the reporter captured at construction time.
-  reset(): this {
-    this.#currentReporter = this.#initialReporter;
-    return this;
-  }
+    // Restores the reporter captured at construction time.
+    reset(): this {
+        this.#currentReporter = this.#initialReporter;
+        return this;
+    }
 
-  getPolicyReporter(): PolicyReporter {
-    return this.#currentReporter;
-  }
+    getPolicyReporter(): PolicyReporter {
+        return this.#currentReporter;
+    }
 
-  getConditionEvaluationOptions(
-    engineVersion: number,
-  ): ConditionEvaluationOptions {
-    return {
-      reporter: this.#bridgeToConditionReporter(this.#currentReporter),
-      engineVersion,
-    };
-  }
+    getConditionEvaluationOptions(
+        engineVersion: number,
+    ): ConditionEvaluationOptions {
+        return {
+            reporter: this.#bridgeToConditionReporter(this.#currentReporter),
+            engineVersion,
+        };
+    }
 
-  #bridgeToConditionReporter(
-    policyReporter: PolicyReporter,
-  ): ConditionEvaluatorReporter {
-    return {
-      warn(report) {
-        reportSafely(policyReporter, {
-          kind: "condition-eval",
-          ...report,
-        } satisfies PolicyEvent);
-      },
-      error(report) {
-        reportSafely(policyReporter, {
-          kind: "condition-eval",
-          ...report,
-        } satisfies PolicyEvent);
-      },
-    };
-  }
+    #bridgeToConditionReporter(
+        policyReporter: PolicyReporter,
+    ): ConditionEvaluatorReporter {
+        return {
+            warn(report) {
+                reportSafely(policyReporter, {
+                    kind: "condition-eval",
+                    ...report,
+                } satisfies PolicyEvent);
+            },
+            error(report) {
+                reportSafely(policyReporter, {
+                    kind: "condition-eval",
+                    ...report,
+                } satisfies PolicyEvent);
+            },
+        };
+    }
 }

package/src/core/config/index.ts

@@ -2,11 +2,11 @@ export type { CoreConfigOptions, CoreObservabilityConfig } from "./core-config";
 export { CoreConfig } from "./core-config";
 export { coreConfig } from "./core-config.instance";
 export type {
-  PolicyEvent,
-  PolicyReporter,
-  ConditionEvalEvent,
-  PolicyResolutionEvent,
-  PolicyEvaluationFailedEvent,
-  PolicyEvaluationCompletedEvent,
+    PolicyEvent,
+    PolicyReporter,
+    ConditionEvalEvent,
+    PolicyResolutionEvent,
+    PolicyEvaluationFailedEvent,
+    PolicyEvaluationCompletedEvent,
 } from "./policy-reporter";
 export { SilentPolicyReporter } from "./silent-policy-reporter";

package/src/core/config/policy-reporter.ts

@@ -1,60 +1,60 @@
 import type { ConditionEvaluationReport } from "../policies/engines/condition-evaluator-reporter";
 import type {
-  PolicyDecisionId,
-  PolicyDefinitionId,
+    PolicyDecisionId,
+    PolicyDefinitionId,
 } from "../policies/policy-ids";
 
 // ─── Event kinds ─────────────────────────────────────────────────────────────
 
 export type ConditionEvalEvent = ConditionEvaluationReport & {
-  readonly kind: "condition-eval";
+    readonly kind: "condition-eval";
 };
 
 export interface PolicyResolutionEvent {
-  readonly kind: "policy-resolution";
-  readonly level: "info";
-  readonly policyKey: string;
-  readonly definitionId: PolicyDefinitionId;
-  readonly policyVersion: string;
-  readonly engineKind: "GATE" | "COMPUTE";
-  readonly engineVersion: number;
-  readonly occurredAt: Date;
+    readonly kind: "policy-resolution";
+    readonly level: "info";
+    readonly policyKey: string;
+    readonly definitionId: PolicyDefinitionId;
+    readonly policyVersion: string;
+    readonly engineKind: "GATE" | "COMPUTE";
+    readonly engineVersion: number;
+    readonly occurredAt: Date;
 }
 
 export interface PolicyEvaluationFailedEvent {
-  readonly kind: "policy-evaluation-failed";
-  readonly level: "error";
-  readonly policyKey: string | undefined;
-  readonly errorKind: string;
-  readonly message: string;
-  readonly cause: string;
-  readonly occurredAt: Date;
+    readonly kind: "policy-evaluation-failed";
+    readonly level: "error";
+    readonly policyKey: string | undefined;
+    readonly errorKind: string;
+    readonly message: string;
+    readonly cause: string;
+    readonly occurredAt: Date;
 }
 
 export interface PolicyEvaluationCompletedEvent {
-  readonly kind: "policy-evaluation-completed";
-  readonly level: "info";
-  readonly policyKey: string;
-  readonly decisionId: PolicyDecisionId;
-  readonly engineKind: "GATE" | "COMPUTE";
-  readonly occurredAt: Date;
+    readonly kind: "policy-evaluation-completed";
+    readonly level: "info";
+    readonly policyKey: string;
+    readonly decisionId: PolicyDecisionId;
+    readonly engineKind: "GATE" | "COMPUTE";
+    readonly occurredAt: Date;
 }
 
 export type PolicyEvent =
-  | ConditionEvalEvent
-  | PolicyResolutionEvent
-  | PolicyEvaluationFailedEvent
-  | PolicyEvaluationCompletedEvent;
+    | ConditionEvalEvent
+    | PolicyResolutionEvent
+    | PolicyEvaluationFailedEvent
+    | PolicyEvaluationCompletedEvent;
 
 // ─── Reporter interface ───────────────────────────────────────────────────────
 
 export interface PolicyReporter {
-  report(event: PolicyEvent): void;
+    report(event: PolicyEvent): void;
 }
 
 // ─── Re-export only what external consumers need for event construction ───────
 
 export type {
-  ConditionEvaluationReport,
-  ConditionEvaluationReportTag,
+    ConditionEvaluationReport,
+    ConditionEvaluationReportTag,
 } from "../policies/engines/condition-evaluator-reporter";

package/src/core/config/silent-policy-reporter.ts

@@ -1,5 +1,5 @@
 import type { PolicyReporter } from "./policy-reporter";
 
 export class SilentPolicyReporter implements PolicyReporter {
-  report(_event: Parameters<PolicyReporter["report"]>[0]): void {}
+    report(_event: Parameters<PolicyReporter["report"]>[0]): void {}
 }

package/src/core/domain/entity.ts

@@ -4,66 +4,66 @@ import { assertValidDate, cloneDate } from "../shared/temporal-guards";
 import { type ContractVersion, version } from "../versioning/version";
 
 interface EntityState<TIdentifier> {
-  readonly id: TIdentifier;
-  readonly createdAt: Date;
-  readonly updatedAt: Date;
-  readonly aggregateVersion: number;
+    readonly id: TIdentifier;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly aggregateVersion: number;
 }
 
 @version("1.0")
 abstract class Entity<TIdentifier> {
-  public static readonly CONTRACT_VERSION: ContractVersion;
+    public static readonly CONTRACT_VERSION: ContractVersion;
 
-  private readonly _id: TIdentifier;
-  private readonly _createdAt: Date;
-  private _updatedAt: Date;
-  private _aggregateVersion: number;
+    private readonly _id: TIdentifier;
+    private readonly _createdAt: Date;
+    private _updatedAt: Date;
+    private _aggregateVersion: number;
 
-  protected constructor(state: EntityState<TIdentifier>) {
-    assertValidDate("createdAt", state.createdAt);
-    assertValidDate("updatedAt", state.updatedAt);
-    assertValidAggregateVersion(state.aggregateVersion);
+    protected constructor(state: EntityState<TIdentifier>) {
+        assertValidDate("createdAt", state.createdAt);
+        assertValidDate("updatedAt", state.updatedAt);
+        assertValidAggregateVersion(state.aggregateVersion);
 
-    if (state.updatedAt.getTime() < state.createdAt.getTime()) {
-      throw new InvariantViolationException(
-        "updatedAt cannot be earlier than createdAt",
-      );
-    }
+        if (state.updatedAt.getTime() < state.createdAt.getTime()) {
+            throw new InvariantViolationException(
+                "updatedAt cannot be earlier than createdAt",
+            );
+        }
 
-    this._id = state.id;
-    this._createdAt = cloneDate(state.createdAt);
-    this._updatedAt = cloneDate(state.updatedAt);
-    this._aggregateVersion = state.aggregateVersion;
-  }
+        this._id = state.id;
+        this._createdAt = cloneDate(state.createdAt);
+        this._updatedAt = cloneDate(state.updatedAt);
+        this._aggregateVersion = state.aggregateVersion;
+    }
 
-  public get id(): TIdentifier {
-    return this._id;
-  }
+    public get id(): TIdentifier {
+        return this._id;
+    }
 
-  public get createdAt(): Date {
-    return cloneDate(this._createdAt);
-  }
+    public get createdAt(): Date {
+        return cloneDate(this._createdAt);
+    }
 
-  public get updatedAt(): Date {
-    return cloneDate(this._updatedAt);
-  }
+    public get updatedAt(): Date {
+        return cloneDate(this._updatedAt);
+    }
 
-  public get aggregateVersion(): number {
-    return this._aggregateVersion;
-  }
+    public get aggregateVersion(): number {
+        return this._aggregateVersion;
+    }
 
-  public get contractVersion(): ContractVersion {
-    return Entity.CONTRACT_VERSION;
-  }
+    public get contractVersion(): ContractVersion {
+        return Entity.CONTRACT_VERSION;
+    }
 
-  protected markAsModified(updatedAt: Date = new Date()): number {
-    assertValidDate("updatedAt", updatedAt);
+    protected markAsModified(updatedAt: Date = new Date()): number {
+        assertValidDate("updatedAt", updatedAt);
 
-    this._updatedAt = cloneDate(updatedAt);
-    this._aggregateVersion += 1;
+        this._updatedAt = cloneDate(updatedAt);
+        this._aggregateVersion += 1;
 
-    return this._aggregateVersion;
-  }
+        return this._aggregateVersion;
+    }
 }
 
 export { Entity, type EntityState };

package/src/core/domain/rulesets/entity-ruleset.contracts.ts

@@ -2,15 +2,15 @@ import { type Ruleset, type RulesetId } from "./ruleset.contracts";
 import { DomainException } from "../../exceptions/domain-exception";
 
 interface CreationRuleset<TData> extends Ruleset {
-  validate(data: TData): void;
+    validate(data: TData): void;
 }
 
 type InvariantRuleset = Ruleset;
 
 export {
-  type CreationRuleset,
-  DomainException,
-  type InvariantRuleset,
-  type Ruleset,
-  type RulesetId,
+    type CreationRuleset,
+    DomainException,
+    type InvariantRuleset,
+    type Ruleset,
+    type RulesetId,
 };