@domain-first/types 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alevnyacow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,15 @@
+<p align="center">
+    <picture>
+        <img src='https://raw.githubusercontent.com/alevnyacow/domain-first-types/refs/heads/main/logo.svg?sanitize=true'>
+    </picture>
+</p>
+
+<p align="center">
+    Type-safe Entities and Value Objects with Standard Schema validation.
+</p>
+
+# Installation
+
+```
+npm i @domain-first/types
+```

package/dist/errors/async-schema-in-sync-parsing-error.d.ts

@@ -0,0 +1,46 @@
+export declare const AsyncSchemaInSyncParsingError: {
+    new (details: Record<string, any>, options?: ErrorOptions): {
+        readonly metadata: import("@domain-first/errors").PlainPrimitivesObject & {
+            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 & {
+            code: string;
+        }>;
+        readonly 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 & {
+            code: string;
+        }>;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    matches: (target: unknown) => boolean | null;
+    is: (target: unknown) => target is {
+        readonly metadata: import("@domain-first/errors").PlainPrimitivesObject & {
+            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 & {
+            code: string;
+        }>;
+        readonly 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 & {
+            code: string;
+        }>;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './async-schema-in-sync-parsing-error';
+export * from './invalid-data-parsing-error';
+export * from './structured-clone-not-found-error';

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

@@ -0,0 +1,62 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export declare const InvalidDataParsingError: {
+    new (details: {
+        parsingIssues: readonly StandardSchemaV1.Issue[];
+        value: unknown;
+    }, options?: ErrorOptions): {
+        readonly metadata: import("@domain-first/errors").PlainPrimitivesObject & {
+            code: string;
+        };
+        readonly details: {
+            parsingIssues: readonly StandardSchemaV1.Issue[];
+            value: unknown;
+        };
+        readonly formattedDetails: import("@domain-first/errors").PlainPrimitivesObject;
+        readonly 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 & {
+            code: string;
+        }>;
+        readonly serializedFull: import("@domain-first/errors").FullTransportedError<{
+            parsingIssues: readonly StandardSchemaV1.Issue[];
+            value: unknown;
+        }, import("@domain-first/errors").PlainPrimitivesObject & {
+            code: string;
+        }>;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    matches: (target: unknown) => boolean | null;
+    is: (target: unknown) => target is {
+        readonly metadata: import("@domain-first/errors").PlainPrimitivesObject & {
+            code: string;
+        };
+        readonly details: {
+            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 & {
+            code: string;
+        }>;
+        get serializedWithNativeData(): import("@domain-first/errors").TransportedErrorWithNativeData<import("@domain-first/errors").PlainPrimitivesObject & {
+            code: string;
+        }>;
+        get serializedFull(): import("@domain-first/errors").FullTransportedError<{
+            parsingIssues: readonly StandardSchemaV1.Issue[];
+            value: unknown;
+        }, import("@domain-first/errors").PlainPrimitivesObject & {
+            code: string;
+        }>;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};

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

@@ -0,0 +1,46 @@
+export declare const StructuredCloneNotFoundError: {
+    new (details: Record<string, any>, options?: ErrorOptions): {
+        readonly metadata: import("@domain-first/errors").PlainPrimitivesObject & {
+            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 & {
+            code: string;
+        }>;
+        readonly 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 & {
+            code: string;
+        }>;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    matches: (target: unknown) => boolean | null;
+    is: (target: unknown) => target is {
+        readonly metadata: import("@domain-first/errors").PlainPrimitivesObject & {
+            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 & {
+            code: string;
+        }>;
+        readonly 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 & {
+            code: string;
+        }>;
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};

package/dist/index.cjs

@@ -0,0 +1,103 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AsyncSchemaInSyncParsingError: ()=>AsyncSchemaInSyncParsingError,
+    InvalidDataParsingError: ()=>InvalidDataParsingError,
+    StructuredCloneNotFoundError: ()=>StructuredCloneNotFoundError,
+    defineValueObjectClass: ()=>defineValueObjectClass
+});
+const errors_namespaceObject = require("@domain-first/errors");
+const AsyncSchemaInSyncParsingError = (0, errors_namespaceObject.defineErrorClass)({
+    code: 'ASYNC_SCHEMA_IN_SYNC_PARSING'
+});
+const InvalidDataParsingError = (0, errors_namespaceObject.defineErrorClass)({
+    code: 'INVALID_DATA_PARSING'
+});
+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({
+        schema,
+        value
+    });
+    if ('issues' in result && result.issues) throw new InvalidDataParsingError({
+        parsingIssues: result.issues,
+        value
+    });
+    return result.value;
+}
+const defineValueObjectClass = (schema)=>{
+    const modelSymbol = Symbol();
+    class ValueObject {
+        static schema = schema;
+        constructor(data){
+            Object.defineProperty(this, modelSymbol, {
+                value: data
+            });
+        }
+        get model() {
+            const thisWithSymbol = this;
+            if (!('structuredClone' in globalThis)) throw new StructuredCloneNotFoundError({});
+            return structuredClone(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;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AsyncSchemaInSyncParsingError",
+    "InvalidDataParsingError",
+    "StructuredCloneNotFoundError",
+    "defineValueObjectClass"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './errors';
+export * from './value-object';

package/dist/index.js

@@ -0,0 +1,56 @@
+import { defineErrorClass } from "@domain-first/errors";
+const AsyncSchemaInSyncParsingError = defineErrorClass({
+    code: 'ASYNC_SCHEMA_IN_SYNC_PARSING'
+});
+const InvalidDataParsingError = defineErrorClass({
+    code: 'INVALID_DATA_PARSING'
+});
+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({
+        schema,
+        value
+    });
+    if ('issues' in result && result.issues) throw new InvalidDataParsingError({
+        parsingIssues: result.issues,
+        value
+    });
+    return result.value;
+}
+const defineValueObjectClass = (schema)=>{
+    const modelSymbol = Symbol();
+    class ValueObject {
+        static schema = schema;
+        constructor(data){
+            Object.defineProperty(this, modelSymbol, {
+                value: data
+            });
+        }
+        get model() {
+            const thisWithSymbol = this;
+            if (!('structuredClone' in globalThis)) throw new StructuredCloneNotFoundError({});
+            return structuredClone(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 };

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;

package/dist/utils/index.d.ts

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

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

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

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

@@ -0,0 +1 @@
+export {};

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

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

package/dist/utils/parse-sync.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/value-object.d.ts

@@ -0,0 +1,18 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export declare const defineValueObjectClass: <Schema extends StandardSchemaV1>(schema: Schema) => {
+    new (data: StandardSchemaV1.InferOutput<Schema>): {
+        get model(): 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>;
+    }>;
+};
+export type InferValueObjectSchema<T> = T extends {
+    schema: StandardSchemaV1;
+} ? StandardSchemaV1.InferOutput<T['schema']> : T extends {
+    model: infer M;
+} ? M : never;

package/dist/value-object.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@domain-first/types",
+    "description": "Type-safe Entities and Value Objects with Standard Schema validation",
+    "license": "MIT",
+    "version": "0.0.1",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/alevnyacow/domain-first-types.git"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "main": "./dist/index.cjs",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "rslib",
+        "check": "biome check --write",
+        "dev": "rslib --watch",
+        "format": "biome format --write",
+        "test": "rstest",
+        "test:watch": "rstest --watch"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.4.15",
+        "@rslib/core": "^0.23.2",
+        "@rstest/adapter-rslib": "^0.10.6",
+        "@rstest/core": "^0.10.6",
+        "@types/node": "^24.13.2",
+        "typescript": "^6.0.3",
+        "valibot": "^1.4.2",
+        "zod": "^4.4.3"
+    },
+    "dependencies": {
+        "@domain-first/errors": "^1.7.0",
+        "@standard-schema/spec": "^1.1.0"
+    }
+}