@domain-first/types 0.0.1 → 1.0.0

package/README.md

@@ -13,3 +13,32 @@
 ```
 npm i @domain-first/types
 ```
+
+# Quick Start
+
+```ts
+import { defineValueObject, defineEntity } from "@domain-first/types";
+// any schema library supporting Standard Schema can be used
+import { z } from "zod";
+
+// 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/errors/async-schema-in-sync-parsing-error.d.ts

@@ -25,14 +25,14 @@ export declare const AsyncSchemaInSyncParsingError: {
             code: string;
         };
         readonly details: Record<string, any>;
-        readonly formattedDetails: import("@domain-first/errors").PlainPrimitivesObject;
-        readonly serialized: import("@domain-first/errors").TransportedError<import("@domain-first/errors").PlainPrimitivesObject & {
+        get formattedDetails(): import("@domain-first/errors").PlainPrimitivesObject;
+        get serialized(): import("@domain-first/errors").TransportedError<import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
-        readonly serializedWithNativeData: import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
+        get serializedWithNativeData(): import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
-        readonly serializedFull: import("@domain-first/errors").FullTransportedError<Record<string, any>, import("@domain-first/errors").PlainPrimitivesObject & {
+        get serializedFull(): import("@domain-first/errors").FullTransportedError<Record<string, any>, import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
         name: string;

package/dist/errors/invalid-data-parsing-error.d.ts

@@ -38,14 +38,14 @@ export declare const InvalidDataParsingError: {
             parsingIssues: readonly StandardSchemaV1.Issue[];
             value: unknown;
         };
-        get formattedDetails(): import("@domain-first/errors").PlainPrimitivesObject;
-        get serialized(): import("@domain-first/errors").TransportedError<import("@domain-first/errors").PlainPrimitivesObject & {
+        readonly formattedDetails: import("@domain-first/errors").PlainPrimitivesObject;
+        readonly serialized: import("@domain-first/errors").TransportedError<import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
-        get serializedWithNativeData(): import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
+        readonly serializedWithNativeData: import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
-        get serializedFull(): import("@domain-first/errors").FullTransportedError<{
+        readonly serializedFull: import("@domain-first/errors").FullTransportedError<{
             parsingIssues: readonly StandardSchemaV1.Issue[];
             value: unknown;
         }, import("@domain-first/errors").PlainPrimitivesObject & {

package/dist/errors/structured-clone-not-found-error.d.ts

@@ -25,14 +25,14 @@ export declare const StructuredCloneNotFoundError: {
             code: string;
         };
         readonly details: Record<string, any>;
-        readonly formattedDetails: import("@domain-first/errors").PlainPrimitivesObject;
-        readonly serialized: import("@domain-first/errors").TransportedError<import("@domain-first/errors").PlainPrimitivesObject & {
+        get formattedDetails(): import("@domain-first/errors").PlainPrimitivesObject;
+        get serialized(): import("@domain-first/errors").TransportedError<import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
-        readonly serializedWithNativeData: import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
+        get serializedWithNativeData(): import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
-        readonly serializedFull: import("@domain-first/errors").FullTransportedError<Record<string, any>, import("@domain-first/errors").PlainPrimitivesObject & {
+        get serializedFull(): import("@domain-first/errors").FullTransportedError<Record<string, any>, import("@domain-first/errors").PlainPrimitivesObject & {
             code: string;
         }>;
         name: string;

package/dist/index.cjs

@@ -31,7 +31,7 @@ __webpack_require__.d(__webpack_exports__, {
     AsyncSchemaInSyncParsingError: ()=>AsyncSchemaInSyncParsingError,
     InvalidDataParsingError: ()=>InvalidDataParsingError,
     StructuredCloneNotFoundError: ()=>StructuredCloneNotFoundError,
-    defineValueObjectClass: ()=>defineValueObjectClass
+    defineValueObject: ()=>defineValueObject
 });
 const errors_namespaceObject = require("@domain-first/errors");
 const AsyncSchemaInSyncParsingError = (0, errors_namespaceObject.defineErrorClass)({
@@ -43,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({
@@ -63,40 +55,40 @@ function parseSync(schema, value) {
     });
     return result.value;
 }
-const defineValueObjectClass = (schema)=>{
+const defineValueObject = (schema)=>{
     const modelSymbol = Symbol();
+    const classSymbol = Symbol();
+    const isThisClass = (target)=>!!target && 'object' == typeof target && classSymbol in target;
     class ValueObject {
-        static schema = schema;
+        static schema = 'function' == typeof schema ? schema(isThisClass) : schema;
         constructor(data){
+            const parsedData = parseSync(ValueObject.schema, data);
             Object.defineProperty(this, modelSymbol, {
-                value: data
+                value: parsedData
+            });
+            Object.defineProperty(this, classSymbol, {
+                value: true
             });
         }
+        static is(target) {
+            return isThisClass(target);
+        }
         get model() {
             const thisWithSymbol = this;
-            if (!('structuredClone' in globalThis)) throw new StructuredCloneNotFoundError({});
-            return structuredClone(thisWithSymbol[modelSymbol]);
+            return thisWithSymbol[modelSymbol];
         }
-        static create = (data)=>{
-            const parsedData = parseSync(schema, data);
-            return new ValueObject(parsedData);
-        };
-        static createWithAsyncSchema = async (data)=>{
-            const parsedData = await parseAsync(schema, data);
-            return new ValueObject(parsedData);
-        };
     }
     return ValueObject;
 };
 exports.AsyncSchemaInSyncParsingError = __webpack_exports__.AsyncSchemaInSyncParsingError;
 exports.InvalidDataParsingError = __webpack_exports__.InvalidDataParsingError;
 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",
     "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,29 +20,29 @@ function parseSync(schema, value) {
     });
     return result.value;
 }
-const defineValueObjectClass = (schema)=>{
+const defineValueObject = (schema)=>{
     const modelSymbol = Symbol();
+    const classSymbol = Symbol();
+    const isThisClass = (target)=>!!target && 'object' == typeof target && classSymbol in target;
     class ValueObject {
-        static schema = schema;
+        static schema = 'function' == typeof schema ? schema(isThisClass) : schema;
         constructor(data){
+            const parsedData = parseSync(ValueObject.schema, data);
             Object.defineProperty(this, modelSymbol, {
-                value: data
+                value: parsedData
             });
+            Object.defineProperty(this, classSymbol, {
+                value: true
+            });
+        }
+        static is(target) {
+            return isThisClass(target);
         }
         get model() {
             const thisWithSymbol = this;
-            if (!('structuredClone' in globalThis)) throw new StructuredCloneNotFoundError({});
-            return structuredClone(thisWithSymbol[modelSymbol]);
+            return thisWithSymbol[modelSymbol];
         }
-        static create = (data)=>{
-            const parsedData = parseSync(schema, data);
-            return new ValueObject(parsedData);
-        };
-        static createWithAsyncSchema = async (data)=>{
-            const parsedData = await parseAsync(schema, data);
-            return new ValueObject(parsedData);
-        };
     }
     return ValueObject;
 };
-export { AsyncSchemaInSyncParsingError, InvalidDataParsingError, 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,15 +1,11 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-export declare const defineValueObjectClass: <Schema extends StandardSchemaV1>(schema: 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(): StandardSchemaV1.InferOutput<Schema>;
+        get model(): DeepReadonly<StandardSchemaV1.InferOutput<Schema>>;
     };
-    schema: Schema;
-    create: (data: StandardSchemaV1.InferInput<Schema>) => {
-        get model(): StandardSchemaV1.InferOutput<Schema>;
-    };
-    createWithAsyncSchema: (data: StandardSchemaV1.InferInput<Schema>) => Promise<{
-        get model(): StandardSchemaV1.InferOutput<Schema>;
-    }>;
+    readonly schema: 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.1",
+    "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>>;