@domain-first/types 0.0.1 → 0.0.2

package/README.md

@@ -13,3 +13,44 @@
 ```
 npm i @domain-first/types
 ```
+
+# Quick Start
+
+## Value Object
+
+```ts
+import { defineValueObjectClass } from "@domain-first/types";
+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 }
+```

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

@@ -30,6 +30,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     AsyncSchemaInSyncParsingError: ()=>AsyncSchemaInSyncParsingError,
     InvalidDataParsingError: ()=>InvalidDataParsingError,
+    S: ()=>S,
     StructuredCloneNotFoundError: ()=>StructuredCloneNotFoundError,
     defineValueObjectClass: ()=>defineValueObjectClass
 });
@@ -63,38 +64,44 @@ function parseSync(schema, value) {
     });
     return result.value;
 }
+class S {
+}
 const defineValueObjectClass = (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)=>isThisClass(target);
+        static async createWithAsyncSchema(data) {
+            const parsedData = await parseAsync(ValueObject.schema, data);
+            return new this(parsedData);
+        }
         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.S = __webpack_exports__.S;
 exports.StructuredCloneNotFoundError = __webpack_exports__.StructuredCloneNotFoundError;
 exports.defineValueObjectClass = __webpack_exports__.defineValueObjectClass;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AsyncSchemaInSyncParsingError",
     "InvalidDataParsingError",
+    "S",
     "StructuredCloneNotFoundError",
     "defineValueObjectClass"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/index.js

@@ -28,29 +28,33 @@ function parseSync(schema, value) {
     });
     return result.value;
 }
+class S {
+}
 const defineValueObjectClass = (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)=>isThisClass(target);
+        static async createWithAsyncSchema(data) {
+            const parsedData = await parseAsync(ValueObject.schema, data);
+            return new this(parsedData);
+        }
         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, S, StructuredCloneNotFoundError, defineValueObjectClass };

package/dist/value-object.d.ts

@@ -1,14 +1,16 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-export declare const defineValueObjectClass: <Schema extends StandardSchemaV1>(schema: Schema) => {
+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)) => {
     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: (target: unknown) => boolean;
+    createWithAsyncSchema(data: StandardSchemaV1.InferInput<Schema>): Promise<{
+        get model(): DeepReadonly<StandardSchemaV1.InferOutput<Schema>>;
     }>;
 };
 export type InferValueObjectSchema<T> = T extends {

package/package.json

@@ -2,7 +2,7 @@
     "name": "@domain-first/types",
     "description": "Type-safe Entities and Value Objects with Standard Schema validation",
     "license": "MIT",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "type": "module",
     "repository": {
         "type": "git",