typedriver 0.8.0

package/build/compile.d.mts

@@ -0,0 +1,11 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import Type from 'typebox';
+import { Validator } from './validator.mjs';
+type TFromTypeScript<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>, Result extends Validator = Validator<Input, Output>> = Result;
+type TFromStandardSchema<Input extends StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferInput<Input>, Result extends Validator = Validator<Input, Output>> = Result;
+type TFromJsonSchema<Input extends Type.TSchema, Output extends unknown = Type.Static<Input>, Result extends Validator = Validator<Input, Output>> = Result;
+/** Compiles a schema into a typed Validator */
+export type TCompile<Schema extends unknown> = (Schema extends string ? TFromTypeScript<Schema> : Schema extends StandardSchemaV1 ? TFromStandardSchema<Schema> : Schema extends Type.TSchema ? TFromJsonSchema<Schema> : TFromJsonSchema<{}>);
+/** Compiles a schema into a typed Validator */
+export declare function compile<const Schema extends unknown>(schema: Schema): TCompile<Schema>;
+export {};

package/build/compile.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { IsJsonSchema, IsStandardSchemaV1, IsTypeScript } from './guard.mjs';
+import { JsonSchemaValidator } from './json-schema/validator.mjs';
+import { StandardSchemaValidator } from './standard-schema/validator.mjs';
+import { TypeScriptValidator } from './typescript/validator.mjs';
+function FromTypeScript(script) {
+    return new TypeScriptValidator(script);
+}
+function FromStandardSchema(schema) {
+    return new StandardSchemaValidator(schema);
+}
+function FromJsonSchema(schema) {
+    return new JsonSchemaValidator(schema);
+}
+/** Compiles a schema into a typed Validator */
+export function compile(schema) {
+    return (IsTypeScript(schema) ? FromTypeScript(schema) :
+        IsStandardSchemaV1(schema) ? FromStandardSchema(schema) :
+            IsJsonSchema(schema) ? FromJsonSchema(schema) :
+                FromJsonSchema({}));
+}

package/build/errors.d.mts

@@ -0,0 +1,11 @@
+export declare class AssertError extends globalThis.Error {
+    readonly errors: object[];
+    constructor(errors: object[]);
+}
+export declare class ParseError extends globalThis.Error {
+    readonly errors: object[];
+    constructor(errors: object[]);
+}
+export declare class UnknownError extends globalThis.Error {
+    constructor(message: string);
+}

package/build/errors.mjs

@@ -0,0 +1,17 @@
+export class AssertError extends globalThis.Error {
+    constructor(errors) {
+        super('AssertError');
+        this.errors = errors;
+    }
+}
+export class ParseError extends globalThis.Error {
+    constructor(errors) {
+        super('ParseError');
+        this.errors = errors;
+    }
+}
+export class UnknownError extends globalThis.Error {
+    constructor(message) {
+        super(`UnknownError: ${message}`);
+    }
+}

package/build/guard.d.mts

@@ -0,0 +1,5 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import Type from 'typebox';
+export declare function IsStandardSchemaV1(value: unknown): value is StandardSchemaV1;
+export declare function IsJsonSchema(value: unknown): value is Type.TSchema;
+export declare function IsTypeScript(value: unknown): value is string;

package/build/guard.mjs

@@ -0,0 +1,43 @@
+// deno-fmt-ignore-file
+import Guard from 'typebox/guard';
+// ------------------------------------------------------------------
+// IsStandardSchemaV1
+// ------------------------------------------------------------------
+function IsStandardSchemaV1Props(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, 'version') &&
+        Guard.HasPropertyKey(value, 'vendor') &&
+        Guard.HasPropertyKey(value, 'validate') &&
+        (Guard.IsEqual(value.version, '1') || // spec
+            Guard.IsEqual(value.version, 1) // arktype
+        ) &&
+        Guard.IsString(value.vendor) &&
+        Guard.IsFunction(value.validate);
+}
+function IsTypicalStandardSchemaV1(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, '~standard') &&
+        IsStandardSchemaV1Props(value['~standard']);
+}
+// ArkType
+function IsNonTypicalStandardSchemaV1(value) {
+    return Guard.IsFunction(value) &&
+        !Guard.IsUndefined(value['~standard']) &&
+        IsStandardSchemaV1Props(value['~standard']);
+}
+export function IsStandardSchemaV1(value) {
+    return IsTypicalStandardSchemaV1(value) ||
+        IsNonTypicalStandardSchemaV1(value);
+}
+// ------------------------------------------------------------------
+// IsJsonSchema
+// ------------------------------------------------------------------
+export function IsJsonSchema(value) {
+    return !IsStandardSchemaV1(value) && Guard.IsObjectNotArray(value);
+}
+// ------------------------------------------------------------------
+// IsTypeScript
+// ------------------------------------------------------------------
+export function IsTypeScript(value) {
+    return Guard.IsString(value);
+}

package/build/index.d.mts

@@ -0,0 +1,3 @@
+export * from './compile.mjs';
+export * from './validator.mjs';
+export * from './static.mjs';

package/build/index.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export * from './compile.mjs';
+export * from './validator.mjs';
+export * from './static.mjs';

package/build/json-schema/index.d.mts

@@ -0,0 +1 @@
+export * from './validator.mjs';

package/build/json-schema/index.mjs

@@ -0,0 +1 @@
+export * from './validator.mjs';

package/build/json-schema/validator.d.mts

@@ -0,0 +1,14 @@
+import { Validator } from '../validator.mjs';
+import Type from 'typebox';
+export declare class JsonSchemaValidator<Input extends Type.TSchema, Output extends unknown = Type.Static<Input>> extends Validator<Input, Output> {
+    private readonly input;
+    private readonly validator;
+    constructor(input: Input);
+    schema(): Input;
+    isJsonSchema(): boolean;
+    asJsonSchema(): unknown;
+    assert(value: unknown): asserts value is Output;
+    check(value: unknown): value is Output;
+    parse(value: unknown): Output;
+    errors(value: unknown): object[];
+}

package/build/json-schema/validator.mjs

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Validator as TBValidator } from 'typebox/compile';
+import { AssertError, ParseError } from '../errors.mjs';
+import { Validator } from '../validator.mjs';
+export class JsonSchemaValidator extends Validator {
+    constructor(input) {
+        super();
+        this.input = input;
+        this.validator = new TBValidator({}, input);
+    }
+    // ----------------------------------------------------------------
+    // Schema
+    // ----------------------------------------------------------------
+    schema() {
+        return this.input;
+    }
+    // ----------------------------------------------------------------
+    // Json Schema
+    // ----------------------------------------------------------------
+    isJsonSchema() {
+        return true;
+    }
+    asJsonSchema() {
+        return this.input;
+    }
+    // ----------------------------------------------------------------
+    // Validation
+    // ----------------------------------------------------------------
+    assert(value) {
+        if (!this.validator.Check(value))
+            throw new AssertError(this.errors(value));
+    }
+    check(value) {
+        return this.validator.Check(value);
+    }
+    parse(value) {
+        if (!this.validator.Check(value))
+            throw new ParseError(this.errors(value));
+        return value;
+    }
+    errors(value) {
+        return this.validator.Errors(value);
+    }
+}

package/build/standard-schema/index.d.mts

@@ -0,0 +1 @@
+export * from './validator.mjs';

package/build/standard-schema/index.mjs

@@ -0,0 +1 @@
+export * from './validator.mjs';

package/build/standard-schema/validator.d.mts

@@ -0,0 +1,13 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Validator } from '../validator.mjs';
+export declare class StandardSchemaValidator<Input extends StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferOutput<Input>> extends Validator<Input, Output> {
+    private readonly input;
+    constructor(input: Input);
+    schema(): Input;
+    isJsonSchema(): boolean;
+    asJsonSchema(): unknown;
+    assert(value: unknown): asserts value is Output;
+    check(value: unknown): value is Output;
+    parse(value: unknown): Output;
+    errors(value: unknown): object[];
+}

package/build/standard-schema/validator.mjs

@@ -0,0 +1,50 @@
+// deno-fmt-ignore-file
+import { AssertError, ParseError, UnknownError } from '../errors.mjs';
+import { Validator } from '../validator.mjs';
+export class StandardSchemaValidator extends Validator {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    // ----------------------------------------------------------------
+    // Schema
+    // ----------------------------------------------------------------
+    schema() {
+        return this.input;
+    }
+    // ----------------------------------------------------------------
+    // Json Schema
+    // ----------------------------------------------------------------
+    isJsonSchema() {
+        return false;
+    }
+    asJsonSchema() {
+        return {};
+    }
+    // ----------------------------------------------------------------
+    // Validation
+    // ----------------------------------------------------------------
+    assert(value) {
+        const result = this.input['~standard'].validate(value);
+        if ('issues' in result)
+            throw new AssertError(result.issues || []);
+    }
+    check(value) {
+        const result = this.input['~standard'].validate(value);
+        return !('issues' in result);
+    }
+    parse(value) {
+        const result = this.input['~standard'].validate(value);
+        if ('issues' in result)
+            throw new ParseError(result.issues || []);
+        if ('value' in result)
+            return result.value;
+        throw new UnknownError('Invalid result');
+    }
+    errors(value) {
+        const result = this.input['~standard'].validate(value);
+        if ('issues' in result)
+            return result.issues || [];
+        return [];
+    }
+}

package/build/static.d.mts

@@ -0,0 +1,10 @@
+import { type StandardSchemaV1 } from '@standard-schema/spec';
+import { type Validator } from './validator.mjs';
+import Type from 'typebox';
+type StaticValidator<_Input extends unknown, Output extends unknown> = (Output);
+type StaticTypeScript<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>> = Output;
+type StaticStandardSchema<Input extends StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferOutput<Input>> = Output;
+type StaticJsonSchema<Input extends Type.TSchema, Output extends unknown = Type.Static<Input>> = Output;
+type StaticInput<Input extends unknown> = (Input extends Validator<infer Input extends unknown, infer Output extends unknown> ? StaticValidator<Input, Output> : Input extends string ? StaticTypeScript<Input> : Input extends StandardSchemaV1 ? StaticStandardSchema<Input> : Input extends Type.TSchema ? StaticJsonSchema<Input> : unknown);
+export type Static<Input, Output = StaticInput<Input>> = Output;
+export {};

package/build/static.mjs

@@ -0,0 +1,2 @@
+// deno-fmt-ignore-file
+export {};

package/build/typescript/index.d.mts

@@ -0,0 +1 @@
+export * from './validator.mjs';

package/build/typescript/index.mjs

@@ -0,0 +1 @@
+export * from './validator.mjs';

package/build/typescript/validator.d.mts

@@ -0,0 +1,15 @@
+import { Validator } from '../validator.mjs';
+import Type from 'typebox';
+export declare class TypeScriptValidator<Input extends string, Schema extends Type.TSchema = Type.TScript<{}, Input>, Output extends unknown = Type.Static<Schema>> extends Validator<Input, Output> {
+    private readonly validator;
+    private readonly script;
+    private readonly jsonschema;
+    constructor(script: Input);
+    schema(): Input;
+    isJsonSchema(): boolean;
+    asJsonSchema(): unknown;
+    check(value: unknown): value is Output;
+    assert(value: unknown): asserts value is Output;
+    parse(value: unknown): Output;
+    errors(value: unknown): object[];
+}

package/build/typescript/validator.mjs

@@ -0,0 +1,46 @@
+// deno-fmt-ignore-file
+import { Validator as TBValidator } from 'typebox/compile';
+import { Validator } from '../validator.mjs';
+import { AssertError, ParseError } from '../errors.mjs';
+import Type from 'typebox';
+export class TypeScriptValidator extends Validator {
+    constructor(script) {
+        super();
+        this.script = script;
+        this.jsonschema = Type.Script(this.script);
+        this.validator = new TBValidator({}, this.jsonschema);
+    }
+    // ----------------------------------------------------------------
+    // Schema
+    // ----------------------------------------------------------------
+    schema() {
+        return this.script;
+    }
+    // ----------------------------------------------------------------
+    // Json Schema
+    // ----------------------------------------------------------------
+    isJsonSchema() {
+        return true;
+    }
+    asJsonSchema() {
+        return this.jsonschema;
+    }
+    // ----------------------------------------------------------------
+    // Validation
+    // ----------------------------------------------------------------
+    check(value) {
+        return this.validator.Check(value);
+    }
+    assert(value) {
+        if (!this.validator.Check(value))
+            throw new AssertError(this.errors(value));
+    }
+    parse(value) {
+        if (!this.validator.Check(value))
+            throw new ParseError(this.errors(value));
+        return value;
+    }
+    errors(value) {
+        return this.validator.Errors(value);
+    }
+}

package/build/validator.d.mts

@@ -0,0 +1,17 @@
+/** Abstract Base for all Validator types. */
+export declare abstract class Validator<Input extends unknown = unknown, Output extends unknown = unknown> {
+    /** Returns the internal schema used by this validator */
+    abstract schema(): Input;
+    /** Asserts a value matches the given schema */
+    abstract assert(value: unknown): asserts value is Output;
+    /** Checks a value matches the given schema */
+    abstract check(value: unknown): value is Output;
+    /** Parses a value and throws if invalid */
+    abstract parse(value: unknown): Output;
+    /** Returns errors for the given value */
+    abstract errors(value: unknown): object[];
+    /** True if the the validator supports Json Schema translation */
+    abstract isJsonSchema(): boolean;
+    /** Returns this validator as Json Schema. */
+    abstract asJsonSchema(): unknown;
+}

package/build/validator.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+/** Abstract Base for all Validator types. */
+export class Validator {
+}

package/license

@@ -0,0 +1,23 @@
+TypeDriver
+
+The MIT License (MIT)
+
+Copyright (c) 2025 Haydn Paterson
+
+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/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "typedriver",
+  "description": "Unified Runtime Validation and Inference Driver for TypeScript",
+  "version": "0.8.0",
+  "keywords": [
+    "typescript",
+    "json-schema",
+    "standard-schema"
+  ],
+  "license": "MIT",
+  "author": "sinclairzx81",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sinclairzx81/typedriver"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "typebox": "^1.0.53"
+  },
+  "type": "module",
+  "types": "./build/index.d.mts",
+  "module": "./build/index.mjs",
+  "exports": {
+    "./standard-schema": {
+      "import": "./build/standard-schema/index.mjs",
+      "default": "./build/standard-schema/index.mjs"
+    },
+    "./json-schema": {
+      "import": "./build/json-schema/index.mjs",
+      "default": "./build/json-schema/index.mjs"
+    },
+    "./typescript": {
+      "import": "./build/typescript/index.mjs",
+      "default": "./build/typescript/index.mjs"
+    },
+    ".": {
+      "import": "./build/index.mjs",
+      "default": "./build/index.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "standard-schema": [
+        "./build/standard-schema/index.d.mts"
+      ],
+      "json-schema": [
+        "./build/json-schema/index.d.mts"
+      ],
+      "typescript": [
+        "./build/typescript/index.d.mts"
+      ],
+      ".": [
+        "./build/index.d.mts"
+      ]
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,214 @@
+<div align='center'>
+
+<h1>TypeDriver</h1>
+
+<p>Unified Runtime Validation and Inference Driver for TypeScript</p>
+
+<img src="typedriver.png" />
+
+<br />
+<br />
+
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Test](https://github.com/sinclairzx81/typedriver/actions/workflows/build.yml/badge.svg)](https://github.com/sinclairzx81/typedriver/actions/workflows/build.yml)
+
+</div>
+
+
+## Example
+
+Compile, Infer and Parse
+
+```typescript
+import { compile, type Static } from 'typedriver'
+
+// Compile
+
+const Vector3 = compile(`{
+  x: number
+  y: number
+  z: number
+}`)                                                 // const Vector3: Validator<... {
+                                                    //   x: number,
+                                                    //   y: number,
+                                                    //   z: number
+                                                    // }>
+
+// Infer
+
+type Vector3 = Static<typeof Vector3>               // type Vector3 = {
+                                                    //   x: number,
+                                                    //   y: number,
+                                                    //   z: number
+                                                    // }
+
+// Parse
+
+const position = Vector3.parse({                    // const position: {
+  x: 0,                                             //   x: number,
+  y: 1,                                             //   y: number,
+  z: 0                                              //   z: number
+})                                                  // } = ...
+```
+
+## Overview
+
+TypeDriver is a unified runtime validation and inference system for Json Schema, Standard Schema, and runtime TypeScript. It is designed for framework integration and offers simple Json Schema and Standard Schema integration using a common validation interface.
+
+License MIT
+
+## Contents
+
+- [Overview](#Overview)
+- [Compile](#Compile)
+- [Validator](#Validator)
+  - [Assert](#Assert)
+  - [Check](#Check)
+  - [Parse](#Parse)
+  - [Errors](#VaErrorslidator)
+- [Static](#Static)
+- [Schema](#Schema)
+- [Contribute](#Contribute)
+
+## Compile
+
+TypeDriver provides a single compile(...) function that accepts Json Schema, Standard Schema or TypeScript definition (expressed as a string). The function returns a Validator instance that can be used to check, parse and assert values.
+
+```typescript
+import { compile } from 'typedriver'
+```
+
+Use the compile function can compile TypeScript types ...
+
+```typescript
+const Vector3 = compile(`{
+  x: number
+  y: number
+  z: number
+}`)                                                // const Vector3: Validator<..., {
+                                                   //   x: number,
+                                                   //   y: number,
+                                                   //   z: number,
+                                                   // }>
+```
+
+... or Json Schema schematics
+
+```typescript
+const Vector3 = compile({                           // const Vector3: Validator<..., {
+  type: 'object',                                   //   x: number,
+  required: ['x', 'y', 'z'],                        //   y: number,
+  properties: {                                     //   z: number
+    x: { type: 'number' },                          // }>
+    y: { type: 'number' },
+    z: { type: 'number' }
+  }
+})
+```
+
+... or libraries that implement Standard Schema.
+
+```typescript
+import * z from 'zod'
+
+const Vector3 = compile(z.object({                  // const Vector3: Validator<..., {
+  x: z.number(),                                    //   x: number,
+  y: z.number(),                                    //   y: number,
+  z: z.number(),                                    //   z: number
+}))                                                 // }>
+```
+
+## Validator
+
+Validators contain functions to assert, parse and check JavaScript values.
+
+### Assert
+
+The assert(...) function will throw if the value is invalid.
+
+```typescript
+// Vector3.assert(value: unknown): asserts value is Vector3
+
+Vector3.assert(value)                               
+```
+
+### Check
+
+The check(...) returns a safe boolean result.
+
+```typescript
+// Vector3.check(value: unknown): value is Vector3
+
+if(Vector3.check(value)) {
+
+  const { x, y, z } = value // safe
+}
+```
+
+### Parse
+
+The parse(...) function checks and returns a value and throws on error.
+
+```typescript
+// Vector3.parse(value: unknown): Vector3
+
+const { x, y, z } = Vector3.parse(value)                 
+```
+
+### Errors
+
+The errors(...) function returns validation errors for a value.
+
+```typescript
+// Vector3.errors(value: unknown): object[]
+
+const errors = Vector3.errors(value)              
+```
+
+## Static
+
+TypeDriver provides a unified inference type called `Static<T>` that can infer types from Validator instances as well as Json Schema, Standard Schema or TypeScript syntax. The following infers a Validator.
+
+```typescript
+import { compile, type Static } from 'typedriver'
+
+const Vector = compile(`{ 
+  x: number,
+  y: number,
+  z: number
+}`)
+
+type Vector = Static<typeof Vector>                 // type Vector = {
+                                                    //   x: number
+                                                    //   y: number
+                                                    //   z: number
+                                                    // }
+```
+
+## Schema
+
+Validator instances provide access to internal schematics if required. They also provide support for Validator to Json Schema translation in some cases, with fallbacks for manual Json Schema transformation if required.
+
+```typescript
+import { compile, type Static } from 'typedriver'
+
+const validator = compile(...)
+
+
+validator.isJsonSchema()    // Returns true if the validator can be converted to 
+                            // Json Schema. This is true when the validator was 
+                            // compiled with Json Schema or TypeScript, but false 
+                            // if it was compiled with Standard Schema.
+
+validator.asJsonSchema()    // Returns the Json Schema for the validator. If the 
+                            // validator was compiled with Standard Schema, an 
+                            // empty {} is returned to indicate an unknown 
+                            // runtime schema.
+
+validator.schema()          // Returns the schema that was passed to compile. This 
+                            // can be used to manually transform the schema if 
+                            // isJsonSchema() returns false.
+```
+
+## Contribute
+
+TypeDriver is open to community contribution. Please ensure you submit an issue before submitting a pull request. This project prefers open community discussion before accepting new features.