@domain-first/types 0.0.2 → 1.0.0

package/README.md

@@ -16,41 +16,29 @@ npm i @domain-first/types
 
 # Quick Start
 
-## Value Object
-
 ```ts
-import { defineValueObjectClass } from "@domain-first/types";
+import { defineValueObject, defineEntity } from "@domain-first/types";
+// any schema library supporting Standard Schema can be used
 import { z } from "zod";
 
-/**
- * Create a value object by extending `defineValueObjectClass`.
- * The constructor validates input using your schema and exposes
- * validated data through `model`, exposed as a deeply readonly type.
- */
-class Pagination extends defineValueObjectClass(
-    z.object({
-        pageSize: z.int().positive(),
-        pageIndex: z.int().positive(),
-    }),
-) {
-    get nextPage(): Pagination {
-        return new Pagination({
-            ...this.model,
-            pageIndex: this.model.pageIndex + 1,
-        });
-    }
-}
-
-const secondPage = new Pagination({
-    pageSize: 10,
-    pageIndex: 2,
-});
-
-secondPage.model.pageIndex;
-// 2
-
-const thirdPage = secondPage.nextPage;
-
-thirdPage.model;
-// { pageSize: 10, pageIndex: 3 }
+// User Id (Value Object)
+class UserId extends defineValueObject(
+    // model schema
+    z.string().nonempty(),
+) {}
+
+// User (Entity)
+class User extends defineEntity(
+    // id schema
+    z.custom<UserId>(UserId.is),
+    // model schema
+    z.object({ name: z.string().nonempty() }),
+) {}
+
+const user = new User(
+    // identifier
+    new UserId("user-1"),
+    // model
+    { name: "First User" },
+);
 ```

package/dist/entity.d.ts

@@ -0,0 +1,21 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { type DeepReadonly } from './utils';
+export declare const defineEntity: <IdSchema extends StandardSchemaV1, ModelSchema extends StandardSchemaV1>(idSchema: IdSchema, modelSchema: ModelSchema | ((isCurrentEntity: (target: unknown) => boolean) => ModelSchema)) => {
+    new (id: StandardSchemaV1.InferOutput<IdSchema>, model: StandardSchemaV1.InferOutput<ModelSchema>): {
+        get model(): DeepReadonly<StandardSchemaV1.InferOutput<ModelSchema>>;
+        get id(): DeepReadonly<StandardSchemaV1.InferOutput<IdSchema>>;
+    };
+    readonly idSchema: IdSchema;
+    readonly modelSchema: ModelSchema;
+    is<T extends abstract new (...args: any[]) => any>(this: T, target: unknown): target is InstanceType<T>;
+};
+export type InferEntityModel<T> = T extends {
+    modelSchema: StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<T['modelSchema']> : T extends {
+    model: infer M;
+} ? M : never;
+export type InferEntityId<T> = T extends {
+    idSchema: StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<T['idSchema']> : T extends {
+    id: infer M;
+} ? M : never;

package/dist/index.cjs

@@ -30,9 +30,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     AsyncSchemaInSyncParsingError: ()=>AsyncSchemaInSyncParsingError,
     InvalidDataParsingError: ()=>InvalidDataParsingError,
-    S: ()=>S,
     StructuredCloneNotFoundError: ()=>StructuredCloneNotFoundError,
-    defineValueObjectClass: ()=>defineValueObjectClass
+    defineValueObject: ()=>defineValueObject
 });
 const errors_namespaceObject = require("@domain-first/errors");
 const AsyncSchemaInSyncParsingError = (0, errors_namespaceObject.defineErrorClass)({
@@ -44,14 +43,6 @@ const InvalidDataParsingError = (0, errors_namespaceObject.defineErrorClass)({
 const StructuredCloneNotFoundError = (0, errors_namespaceObject.defineErrorClass)({
     code: 'STRUCTURED_CLONE_NOT_FOUND'
 });
-async function parseAsync(schema, value) {
-    const result = await schema['~standard'].validate(value);
-    if ('issues' in result && result.issues) throw new InvalidDataParsingError({
-        parsingIssues: result.issues,
-        value
-    });
-    return result.value;
-}
 function parseSync(schema, value) {
     const result = schema['~standard'].validate(value);
     if (result instanceof Promise) throw new AsyncSchemaInSyncParsingError({
@@ -64,9 +55,7 @@ function parseSync(schema, value) {
     });
     return result.value;
 }
-class S {
-}
-const defineValueObjectClass = (schema)=>{
+const defineValueObject = (schema)=>{
     const modelSymbol = Symbol();
     const classSymbol = Symbol();
     const isThisClass = (target)=>!!target && 'object' == typeof target && classSymbol in target;
@@ -81,10 +70,8 @@ const defineValueObjectClass = (schema)=>{
                 value: true
             });
         }
-        static is = (target)=>isThisClass(target);
-        static async createWithAsyncSchema(data) {
-            const parsedData = await parseAsync(ValueObject.schema, data);
-            return new this(parsedData);
+        static is(target) {
+            return isThisClass(target);
         }
         get model() {
             const thisWithSymbol = this;
@@ -95,15 +82,13 @@ const defineValueObjectClass = (schema)=>{
 };
 exports.AsyncSchemaInSyncParsingError = __webpack_exports__.AsyncSchemaInSyncParsingError;
 exports.InvalidDataParsingError = __webpack_exports__.InvalidDataParsingError;
-exports.S = __webpack_exports__.S;
 exports.StructuredCloneNotFoundError = __webpack_exports__.StructuredCloneNotFoundError;
-exports.defineValueObjectClass = __webpack_exports__.defineValueObjectClass;
+exports.defineValueObject = __webpack_exports__.defineValueObject;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AsyncSchemaInSyncParsingError",
     "InvalidDataParsingError",
-    "S",
     "StructuredCloneNotFoundError",
-    "defineValueObjectClass"
+    "defineValueObject"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './errors';
+export type { DeepReadonly } from './utils';
 export * from './value-object';

package/dist/index.js

@@ -8,14 +8,6 @@ const InvalidDataParsingError = defineErrorClass({
 const StructuredCloneNotFoundError = defineErrorClass({
     code: 'STRUCTURED_CLONE_NOT_FOUND'
 });
-async function parseAsync(schema, value) {
-    const result = await schema['~standard'].validate(value);
-    if ('issues' in result && result.issues) throw new InvalidDataParsingError({
-        parsingIssues: result.issues,
-        value
-    });
-    return result.value;
-}
 function parseSync(schema, value) {
     const result = schema['~standard'].validate(value);
     if (result instanceof Promise) throw new AsyncSchemaInSyncParsingError({
@@ -28,9 +20,7 @@ function parseSync(schema, value) {
     });
     return result.value;
 }
-class S {
-}
-const defineValueObjectClass = (schema)=>{
+const defineValueObject = (schema)=>{
     const modelSymbol = Symbol();
     const classSymbol = Symbol();
     const isThisClass = (target)=>!!target && 'object' == typeof target && classSymbol in target;
@@ -45,10 +35,8 @@ const defineValueObjectClass = (schema)=>{
                 value: true
             });
         }
-        static is = (target)=>isThisClass(target);
-        static async createWithAsyncSchema(data) {
-            const parsedData = await parseAsync(ValueObject.schema, data);
-            return new this(parsedData);
+        static is(target) {
+            return isThisClass(target);
         }
         get model() {
             const thisWithSymbol = this;
@@ -57,4 +45,4 @@ const defineValueObjectClass = (schema)=>{
     }
     return ValueObject;
 };
-export { AsyncSchemaInSyncParsingError, InvalidDataParsingError, S, StructuredCloneNotFoundError, defineValueObjectClass };
+export { AsyncSchemaInSyncParsingError, InvalidDataParsingError, StructuredCloneNotFoundError, defineValueObject };

package/dist/utils/index.d.ts

@@ -1,2 +1,2 @@
-export * from './parse-async';
 export * from './parse-sync';
+export * from './types';

package/dist/value-object.d.ts

@@ -1,17 +1,11 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { DeepReadonly } from './types';
-export declare abstract class S<Schema extends StandardSchemaV1> {
-    abstract schema: Schema;
-}
-export declare const defineValueObjectClass: <Schema extends StandardSchemaV1>(schema: Schema | ((isCurrentValueObject: (target: unknown) => boolean) => Schema)) => {
+import { type DeepReadonly } from './utils';
+export declare const defineValueObject: <Schema extends StandardSchemaV1>(schema: Schema | ((isCurrentValueObject: (target: unknown) => boolean) => Schema)) => {
     new (data: StandardSchemaV1.InferOutput<Schema>): {
         get model(): DeepReadonly<StandardSchemaV1.InferOutput<Schema>>;
     };
     readonly schema: Schema;
-    is: (target: unknown) => boolean;
-    createWithAsyncSchema(data: StandardSchemaV1.InferInput<Schema>): Promise<{
-        get model(): DeepReadonly<StandardSchemaV1.InferOutput<Schema>>;
-    }>;
+    is<T extends abstract new (...args: any[]) => any>(this: T, target: unknown): target is InstanceType<T>;
 };
 export type InferValueObjectSchema<T> = T extends {
     schema: StandardSchemaV1;

package/package.json

@@ -2,7 +2,15 @@
     "name": "@domain-first/types",
     "description": "Type-safe Entities and Value Objects with Standard Schema validation",
     "license": "MIT",
-    "version": "0.0.2",
+    "keywords": [
+        "entity",
+        "value-object",
+        "value object",
+        "vo",
+        "domain model",
+        "domain-first"
+    ],
+    "version": "1.0.0",
     "type": "module",
     "repository": {
         "type": "git",
@@ -36,7 +44,11 @@
         "@rslib/core": "^0.23.2",
         "@rstest/adapter-rslib": "^0.10.6",
         "@rstest/core": "^0.10.6",
+        "@semantic-release/changelog": "^6.0.3",
+        "@semantic-release/git": "^10.0.1",
+        "@semantic-release/npm": "^13.1.5",
         "@types/node": "^24.13.2",
+        "semantic-release": "^25.0.8",
         "typescript": "^6.0.3",
         "valibot": "^1.4.2",
         "zod": "^4.4.3"

package/dist/utils/parse-async.d.ts

@@ -1,2 +0,0 @@
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-export declare function parseAsync<S extends StandardSchemaV1>(schema: S, value: StandardSchemaV1.InferInput<S>): Promise<StandardSchemaV1.InferOutput<S>>;