@schorts/shared-kernel 1.0.4 → 1.0.5

package/CHANGELOG

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.5] - 2025-09-30
+
+### Added
+
+- Introduce `DAO` concept for a related package with a `Firestore` implementation.
+- Introduce `UnitOfWOrk` concept for a related package with a `Firestore` implementation.
+
 ## [1.0.4] - 2025-09-30
 
 ### Fixed
@@ -21,5 +28,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Removed indirect dependencies from the `package.json`.
 
-[1.0.3]: https://github.com/schorts99/shared-kernel/compare/v1.0.3...v0.0.4
+[1.0.5]: https://github.com/schorts99/shared-kernel/compare/v1.0.4...v0.0.5
+[1.0.4]: https://github.com/schorts99/shared-kernel/compare/v1.0.3...v0.0.4
 [1.0.3]: https://github.com/schorts99/shared-kernel/releases/tag/v1.0.3

package/README.md

@@ -44,6 +44,11 @@ npm install @schorts/shared-kernel --save
 
 - **BaseModel:** Base class for serializable, type-safe models.
 
+### 🛠 Persistence
+
+- **DAO:** Generic interface defining data access operations for domain entities.
+- **UnitOfWork:** Interface enabling transactional coordination across multiple persistence operations.
+
 ### 🧠 State Manager
 
 - **StateManager:** Abstract reactive state manager with listener support.

package/__tests__/dao/dao.test.ts

@@ -0,0 +1,116 @@
+import { expectTypeOf } from "expect-type";
+
+import { DAO } from "../../src/dao";
+import { Entity } from "../../src/entities";
+import { Criteria } from "../../src/criteria";
+
+type Model = {
+  id: string;
+  name: string;
+};
+
+class ModelEntity extends Entity<Model> {
+  toPrimitives(): Model {
+    throw new Error("Method not implemented.");
+  }
+}
+
+describe("DAO", () => {
+  describe('#getAll', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("getAll");
+    });
+
+    it('should no require any arguments', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['getAll']>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return a promise with the Entity', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['getAll']>().returns.toEqualTypeOf<Promise<ModelEntity[]>>();
+    });
+  });
+
+  describe('#findByID', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("findByID");
+    });
+
+    it('should require the ID argument', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['findByID']>().parameters.toEqualTypeOf<[ModelEntity["id"]["value"]]>();
+    });
+
+    it('should return a promise with the Entity or null', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['findByID']>().returns.toEqualTypeOf<Promise<ModelEntity | null>>();
+    });
+  });
+
+  describe('#findOneBy', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("findOneBy");
+    });
+
+    it('should receive the criteria', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['findOneBy']>().parameters.toEqualTypeOf<[Criteria]>();
+    });
+
+    it('should return a promise with the Entity or null', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['findOneBy']>().returns.toEqualTypeOf<Promise<ModelEntity | null>>();
+    });
+  });
+
+  describe('#search', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("search");
+    });
+
+    it('should receive the criteria argument', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['search']>().parameters.toEqualTypeOf<[Criteria]>();
+    });
+
+    it('should return a promise with an array of entities', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['search']>().returns.toEqualTypeOf<Promise<ModelEntity[]>>();
+    });
+  });
+
+  describe('#create', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("create");
+    });
+
+    it('should receive the entity argument', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['create']>().parameters.toEqualTypeOf<[ModelEntity]>();
+    });
+
+    it('should return a promise with the created entity', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['create']>().returns.toEqualTypeOf<Promise<ModelEntity>>();
+    });
+  });
+
+  describe('#update', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("update");
+    });
+
+    it('should receive the entity argument', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['update']>().parameters.toEqualTypeOf<[ModelEntity]>();
+    });
+
+    it('should return a promise with the updated entity', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['update']>().returns.toEqualTypeOf<Promise<ModelEntity>>();
+    });
+  });
+
+  describe('#delete', () => {
+    it('should declare the method', () => {
+      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("delete");
+    });
+
+    it('should receive the entity argument', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['delete']>().parameters.toEqualTypeOf<[ModelEntity]>();
+    });
+
+    it('should return a promise with the deleted entity', () => {
+      expectTypeOf<DAO<Model, ModelEntity>['delete']>().returns.toEqualTypeOf<Promise<ModelEntity>>();
+    });
+  });
+});

package/__tests__/unit-of-work/unit-of-work.test.ts

@@ -0,0 +1,47 @@
+import { expectTypeOf } from "expect-type";
+
+import { UnitOfWork } from "../../src/unit-of-work";
+
+describe("UnitOfWork", () => {
+  describe('#begin', () => {
+    it('should declare the method', () => {
+      expectTypeOf<UnitOfWork>().toHaveProperty("begin");
+    });
+
+    it('should no require any arguments', () => {
+      expectTypeOf<UnitOfWork['begin']>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return a promise', () => {
+      expectTypeOf<UnitOfWork['begin']>().returns.toEqualTypeOf<Promise<void>>();
+    });
+  })
+
+  describe('#commit', () => {
+    it('should declare the method', () => {
+      expectTypeOf<UnitOfWork>().toHaveProperty("commit");
+    });
+
+    it('should no require any arguments', () => {
+      expectTypeOf<UnitOfWork['commit']>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return a promise', () => {
+      expectTypeOf<UnitOfWork['commit']>().returns.toEqualTypeOf<Promise<void>>();
+    });
+  })
+
+  describe('#rollback', () => {
+    it('should declare the method', () => {
+      expectTypeOf<UnitOfWork>().toHaveProperty("rollback");
+    });
+
+    it('should no require any arguments', () => {
+      expectTypeOf<UnitOfWork['rollback']>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return a promise', () => {
+      expectTypeOf<UnitOfWork['rollback']>().returns.toEqualTypeOf<Promise<void>>();
+    });
+  })
+});

package/jest.config.js

@@ -1,5 +1,5 @@
-  // jest.config.js
-  const { defaults: tsjPreset } = require("ts-jest/presets");
+// jest.config.js
+const { defaults: tsjPreset } = require("ts-jest/presets");
 const { transform } = require("typescript");
 
   module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schorts/shared-kernel",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "A modular, type-safe foundation for building expressive, maintainable applications. This package provides core abstractions for domain modeling, HTTP integration, authentication, state management, and more — designed to be framework-agnostic and highly extensible.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -13,6 +13,10 @@
       "import": "./dist/criteria/index.js",
       "types": "./dist/criteria/index.d.ts"
     },
+    "./dao": {
+      "import": "./dist/dao/index.js",
+      "types": "./dist/dao/index.d.ts"
+    },
     "./domain-events": {
       "import": "./dist/domain-events/index.js",
       "types": "./dist/domain-events/index.d.ts"
@@ -41,6 +45,10 @@
       "import": "./dist/models/index.js",
       "types": "./dist/models/index.d.ts"
     },
+    "./unit-of-work": {
+      "import": "./dist/unit-of-work/index.js",
+      "types": "./dist/unit-of-work/index.d.ts"
+    },
     "./utils": {
       "import": "./dist/utils/index.js",
       "types": "./dist/utils/index.d.ts"
@@ -81,6 +89,7 @@
     "shared-kernel",
     "auth",
     "jsonapi",
+    "dao",
     "kernel",
     "value-objects",
     "criteria",

package/src/dao/dao.ts

@@ -0,0 +1,13 @@
+import { BaseModel } from "../models";
+import { Entity as BaseEntity } from "../entities";
+import { Criteria } from "../criteria";
+
+export interface DAO<Model extends BaseModel, Entity extends BaseEntity<Model>> {
+  getAll(): Promise<Entity[]>;
+  findByID(id: Entity["id"]["value"]): Promise<Entity | null>;
+  findOneBy(criteria: Criteria): Promise<Entity | null>;
+  search(criteria: Criteria): Promise<Entity[]>;
+  create(entity: Entity): Promise<Entity>;
+  update(entity: Entity): Promise<Entity>;
+  delete(entity: Entity): Promise<Entity>;
+}

package/src/dao/index.ts

@@ -0,0 +1 @@
+export type { DAO } from "./dao";

package/src/unit-of-work/index.ts

@@ -0,0 +1 @@
+export type { UnitOfWork } from "./unit-of-work";

package/src/unit-of-work/unit-of-work.ts

@@ -0,0 +1,5 @@
+export interface UnitOfWork {
+  begin(): Promise<void>;
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}