@gravito/enterprise 0.1.0 → 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,76 @@
+/**
+ * Base Command
+ *
+ * Represents an intent to change the state of the system.
+ */
+declare abstract class Command {
+    constructor();
+}
+/**
+ * Command Handler Interface
+ */
+interface CommandHandler<TCommand extends Command, TResult = void> {
+    handle(command: TCommand): Promise<TResult>;
+}
+
+/**
+ * Base Query
+ *
+ * Represents an intent to retrieve data from the system.
+ */
+declare abstract class Query {
+    constructor();
+}
+/**
+ * Query Handler Interface
+ */
+interface QueryHandler<TQuery extends Query, TResult> {
+    handle(query: TQuery): Promise<TResult>;
+}
+
+declare abstract class UseCase<TInput, TOutput> {
+    constructor();
+    abstract execute(input: TInput): Promise<TOutput> | TOutput;
+}
+
+declare abstract class DomainEvent {
+    readonly occurredOn: Date;
+    readonly eventId: string;
+    constructor(eventId?: string, occurredOn?: Date);
+    get eventName(): string;
+}
+
+declare abstract class Entity<TId> {
+    protected readonly _id: TId;
+    constructor(id: TId);
+    get id(): TId;
+    equals(other: Entity<TId>): boolean;
+}
+
+/**
+ * Aggregate Root
+ *
+ * A DDD aggregate root that can record and clear domain events.
+ */
+declare abstract class AggregateRoot<TId> extends Entity<TId> {
+    private _domainEvents;
+    protected addDomainEvent(event: DomainEvent): void;
+    pullDomainEvents(): DomainEvent[];
+    clearDomainEvents(): void;
+}
+
+interface Repository<TEntity extends Entity<TId>, TId> {
+    save(entity: TEntity): Promise<void>;
+    findById(id: TId): Promise<TEntity | null>;
+    findAll(): Promise<TEntity[]>;
+    delete(id: TId): Promise<void>;
+    exists(id: TId): Promise<boolean>;
+}
+
+declare abstract class ValueObject<T> {
+    protected readonly props: T;
+    constructor(props: T);
+    equals(other: ValueObject<T>): boolean;
+}
+
+export { AggregateRoot, Command, type CommandHandler, DomainEvent, Entity, Query, type QueryHandler, type Repository, UseCase, ValueObject };

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Base Command
+ *
+ * Represents an intent to change the state of the system.
+ */
+declare abstract class Command {
+    constructor();
+}
+/**
+ * Command Handler Interface
+ */
+interface CommandHandler<TCommand extends Command, TResult = void> {
+    handle(command: TCommand): Promise<TResult>;
+}
+
+/**
+ * Base Query
+ *
+ * Represents an intent to retrieve data from the system.
+ */
+declare abstract class Query {
+    constructor();
+}
+/**
+ * Query Handler Interface
+ */
+interface QueryHandler<TQuery extends Query, TResult> {
+    handle(query: TQuery): Promise<TResult>;
+}
+
+declare abstract class UseCase<TInput, TOutput> {
+    constructor();
+    abstract execute(input: TInput): Promise<TOutput> | TOutput;
+}
+
+declare abstract class DomainEvent {
+    readonly occurredOn: Date;
+    readonly eventId: string;
+    constructor(eventId?: string, occurredOn?: Date);
+    get eventName(): string;
+}
+
+declare abstract class Entity<TId> {
+    protected readonly _id: TId;
+    constructor(id: TId);
+    get id(): TId;
+    equals(other: Entity<TId>): boolean;
+}
+
+/**
+ * Aggregate Root
+ *
+ * A DDD aggregate root that can record and clear domain events.
+ */
+declare abstract class AggregateRoot<TId> extends Entity<TId> {
+    private _domainEvents;
+    protected addDomainEvent(event: DomainEvent): void;
+    pullDomainEvents(): DomainEvent[];
+    clearDomainEvents(): void;
+}
+
+interface Repository<TEntity extends Entity<TId>, TId> {
+    save(entity: TEntity): Promise<void>;
+    findById(id: TId): Promise<TEntity | null>;
+    findAll(): Promise<TEntity[]>;
+    delete(id: TId): Promise<void>;
+    exists(id: TId): Promise<boolean>;
+}
+
+declare abstract class ValueObject<T> {
+    protected readonly props: T;
+    constructor(props: T);
+    equals(other: ValueObject<T>): boolean;
+}
+
+export { AggregateRoot, Command, type CommandHandler, DomainEvent, Entity, Query, type QueryHandler, type Repository, UseCase, ValueObject };

package/dist/index.js

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AggregateRoot: () => AggregateRoot,
+  Command: () => Command,
+  DomainEvent: () => DomainEvent,
+  Entity: () => Entity,
+  Query: () => Query,
+  UseCase: () => UseCase,
+  ValueObject: () => ValueObject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Application/Command.ts
+var Command = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mark constructor for coverage without changing behavior
+  constructor() {
+  }
+};
+
+// src/Application/Query.ts
+var Query = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mark constructor for coverage without changing behavior
+  constructor() {
+  }
+};
+
+// src/Application/UseCase.ts
+var UseCase = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mark constructor for coverage without changing behavior
+  constructor() {
+  }
+};
+
+// src/Domain/Entity.ts
+var Entity = class _Entity {
+  _id;
+  constructor(id) {
+    this._id = id;
+  }
+  get id() {
+    return this._id;
+  }
+  equals(other) {
+    if (other === null || other === void 0) {
+      return false;
+    }
+    if (this === other) {
+      return true;
+    }
+    if (!(other instanceof _Entity)) {
+      return false;
+    }
+    return this._id === other._id;
+  }
+};
+
+// src/Domain/AggregateRoot.ts
+var AggregateRoot = class extends Entity {
+  _domainEvents = [];
+  addDomainEvent(event) {
+    this._domainEvents.push(event);
+  }
+  pullDomainEvents() {
+    const events = [...this._domainEvents];
+    this._domainEvents = [];
+    return events;
+  }
+  clearDomainEvents() {
+    this._domainEvents = [];
+  }
+};
+
+// src/Domain/DomainEvent.ts
+var DomainEvent = class {
+  occurredOn;
+  eventId;
+  constructor(eventId, occurredOn) {
+    this.eventId = eventId || crypto.randomUUID();
+    this.occurredOn = occurredOn || /* @__PURE__ */ new Date();
+  }
+  get eventName() {
+    return this.constructor.name;
+  }
+};
+
+// src/Domain/ValueObject.ts
+var ValueObject = class {
+  props;
+  constructor(props) {
+    this.props = Object.freeze({ ...props });
+  }
+  equals(other) {
+    if (other === null || other === void 0) {
+      return false;
+    }
+    if (this === other) {
+      return true;
+    }
+    if (other.constructor !== this.constructor) {
+      return false;
+    }
+    return JSON.stringify(this.props) === JSON.stringify(other.props);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AggregateRoot,
+  Command,
+  DomainEvent,
+  Entity,
+  Query,
+  UseCase,
+  ValueObject
+});

package/dist/index.mjs

@@ -0,0 +1,101 @@
+// src/Application/Command.ts
+var Command = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mark constructor for coverage without changing behavior
+  constructor() {
+  }
+};
+
+// src/Application/Query.ts
+var Query = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mark constructor for coverage without changing behavior
+  constructor() {
+  }
+};
+
+// src/Application/UseCase.ts
+var UseCase = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mark constructor for coverage without changing behavior
+  constructor() {
+  }
+};
+
+// src/Domain/Entity.ts
+var Entity = class _Entity {
+  _id;
+  constructor(id) {
+    this._id = id;
+  }
+  get id() {
+    return this._id;
+  }
+  equals(other) {
+    if (other === null || other === void 0) {
+      return false;
+    }
+    if (this === other) {
+      return true;
+    }
+    if (!(other instanceof _Entity)) {
+      return false;
+    }
+    return this._id === other._id;
+  }
+};
+
+// src/Domain/AggregateRoot.ts
+var AggregateRoot = class extends Entity {
+  _domainEvents = [];
+  addDomainEvent(event) {
+    this._domainEvents.push(event);
+  }
+  pullDomainEvents() {
+    const events = [...this._domainEvents];
+    this._domainEvents = [];
+    return events;
+  }
+  clearDomainEvents() {
+    this._domainEvents = [];
+  }
+};
+
+// src/Domain/DomainEvent.ts
+var DomainEvent = class {
+  occurredOn;
+  eventId;
+  constructor(eventId, occurredOn) {
+    this.eventId = eventId || crypto.randomUUID();
+    this.occurredOn = occurredOn || /* @__PURE__ */ new Date();
+  }
+  get eventName() {
+    return this.constructor.name;
+  }
+};
+
+// src/Domain/ValueObject.ts
+var ValueObject = class {
+  props;
+  constructor(props) {
+    this.props = Object.freeze({ ...props });
+  }
+  equals(other) {
+    if (other === null || other === void 0) {
+      return false;
+    }
+    if (this === other) {
+      return true;
+    }
+    if (other.constructor !== this.constructor) {
+      return false;
+    }
+    return JSON.stringify(this.props) === JSON.stringify(other.props);
+  }
+};
+export {
+  AggregateRoot,
+  Command,
+  DomainEvent,
+  Entity,
+  Query,
+  UseCase,
+  ValueObject
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravito/enterprise",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Enterprise architecture primitives for Gravito framework (DDD/Clean Architecture)",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -14,7 +14,7 @@
     "build": "tsup src/index.ts --format cjs,esm --dts",
     "test": "bun test",
     "lint": "biome check .",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "bun tsc -p tsconfig.json --noEmit --skipLibCheck",
     "test:coverage": "bun test --coverage --coverage-threshold=80",
     "test:ci": "bun test --coverage --coverage-threshold=80"
   },
@@ -30,14 +30,14 @@
   "author": "Gravito Team",
   "license": "MIT",
   "dependencies": {
-    "gravito-core": "workspace:*"
+    "@gravito/core": "workspace:*"
   },
   "devDependencies": {
     "tsup": "^8.0.0",
-    "typescript": "^5.0.0",
+    "typescript": "^5.9.3",
     "bun-types": "latest"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}