typedriver 0.8.0 → 0.8.1

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

@@ -0,0 +1,120 @@
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    export interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    export interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    export type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Typed. */
+    export type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+    export {};
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    export type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    export interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    export interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    export interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    export interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    export interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+    export {};
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    export interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    export type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
+    /** The options for the input/output methods. */
+    export interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+    export {};
+}

package/build/_standard/standard-schema.mjs

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

package/build/compile.d.mts

@@ -1,11 +1,12 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
 import Type from 'typebox';
+import { type StandardSchemaV1, type StandardJSONSchemaV1 } from './_standard/standard-schema.mjs';
 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 TFromStandardJsonSchema<Input extends StandardSchemaV1 & StandardJSONSchemaV1, 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;
+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;
 /** 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<{}>);
+export type TCompile<Schema extends unknown> = (Schema extends string ? TFromTypeScript<Schema> : Schema extends StandardSchemaV1 ? (Schema extends StandardJSONSchemaV1 ? TFromStandardJsonSchema<Schema> : 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

@@ -1,21 +1,27 @@
 // deno-fmt-ignore-file
-import { IsJsonSchema, IsStandardSchemaV1, IsTypeScript } from './guard.mjs';
+import { IsJsonSchema, IsStandardSchemaV1, IsStandardJsonSchemaV1, IsTypeScript } from './guard/index.mjs';
 import { JsonSchemaValidator } from './json-schema/validator.mjs';
+import { StandardJsonSchemaValidator } from './standard-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 FromStandardJsonSchema(schema) {
+    return new StandardJsonSchemaValidator(schema);
+}
 function FromJsonSchema(schema) {
     return new JsonSchemaValidator(schema);
 }
+function FromTypeScript(script) {
+    return new TypeScriptValidator(script);
+}
 /** Compiles a schema into a typed Validator */
 export function compile(schema) {
     return (IsTypeScript(schema) ? FromTypeScript(schema) :
-        IsStandardSchemaV1(schema) ? FromStandardSchema(schema) :
+        IsStandardSchemaV1(schema) ? (IsStandardJsonSchemaV1(schema)
+            ? FromStandardJsonSchema(schema)
+            : FromStandardSchema(schema)) :
             IsJsonSchema(schema) ? FromJsonSchema(schema) :
                 FromJsonSchema({}));
 }

package/build/errors.d.mts

@@ -1,7 +1,3 @@
-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[]);

package/build/errors.mjs

@@ -1,9 +1,4 @@
-export class AssertError extends globalThis.Error {
-    constructor(errors) {
-        super('AssertError');
-        this.errors = errors;
-    }
-}
+// deno-fmt-ignore-file
 export class ParseError extends globalThis.Error {
     constructor(errors) {
         super('ParseError');

package/build/guard/index.d.mts

@@ -0,0 +1,4 @@
+export * from './json-schema.mjs';
+export * from './standard-json-schema.mjs';
+export * from './standard-schema.mjs';
+export * from './typescript.mjs';

package/build/guard/index.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+export * from './json-schema.mjs';
+export * from './standard-json-schema.mjs';
+export * from './standard-schema.mjs';
+export * from './typescript.mjs';

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

@@ -0,0 +1,3 @@
+import Type from 'typebox';
+/** Tests if the given schema is JsonSchema like */
+export declare function IsJsonSchema(value: unknown): value is Type.TSchema;

package/build/guard/json-schema.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import Guard from 'typebox/guard';
+import { IsStandardSchemaV1 } from '../guard/index.mjs';
+/** Tests if the given schema is JsonSchema like */
+export function IsJsonSchema(value) {
+    return !IsStandardSchemaV1(value) && Guard.IsObjectNotArray(value);
+}

package/build/guard/standard-json-schema.d.mts

@@ -0,0 +1,2 @@
+import { StandardSchemaV1, StandardJSONSchemaV1 } from '../_standard/standard-schema.mjs';
+export declare function IsStandardJsonSchemaV1(value: unknown): value is StandardSchemaV1 & StandardJSONSchemaV1;

package/build/guard/standard-json-schema.mjs

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import Guard from 'typebox/guard';
+function IsStandardJsonSchemaConverter(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, 'input')
+        && Guard.HasPropertyKey(value, 'output');
+}
+function IsStandardJsonSchemaV1Props(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, 'version') &&
+        Guard.HasPropertyKey(value, 'vendor') &&
+        Guard.HasPropertyKey(value, 'jsonSchema') &&
+        (Guard.IsEqual(value.version, '1') || // spec
+            Guard.IsEqual(value.version, 1) // arktype
+        ) &&
+        Guard.IsString(value.vendor) &&
+        IsStandardJsonSchemaConverter(value.jsonSchema);
+}
+function IsTypicalStandardJsonSchemaV1(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, '~standard') &&
+        IsStandardJsonSchemaV1Props(value['~standard']);
+}
+// ArkType (Obviously)
+function IsNonTypicalStandardJsonSchemaV1(value) {
+    return Guard.IsFunction(value) &&
+        !Guard.IsUndefined(value['~standard']) &&
+        IsStandardJsonSchemaV1Props(value['~standard']);
+}
+export function IsStandardJsonSchemaV1(value) {
+    return IsTypicalStandardJsonSchemaV1(value) ||
+        IsNonTypicalStandardJsonSchemaV1(value);
+}

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

@@ -0,0 +1,2 @@
+import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
+export declare function IsStandardSchemaV1(value: unknown): value is StandardSchemaV1;

package/build/{guard.mjs → guard/standard-schema.mjs}

@@ -1,8 +1,5 @@
 // deno-fmt-ignore-file
 import Guard from 'typebox/guard';
-// ------------------------------------------------------------------
-// IsStandardSchemaV1
-// ------------------------------------------------------------------
 function IsStandardSchemaV1Props(value) {
     return Guard.IsObject(value) &&
         Guard.HasPropertyKey(value, 'version') &&
@@ -19,7 +16,7 @@ function IsTypicalStandardSchemaV1(value) {
         Guard.HasPropertyKey(value, '~standard') &&
         IsStandardSchemaV1Props(value['~standard']);
 }
-// ArkType
+// ArkType (Obviously)
 function IsNonTypicalStandardSchemaV1(value) {
     return Guard.IsFunction(value) &&
         !Guard.IsUndefined(value['~standard']) &&
@@ -29,15 +26,3 @@ 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/guard/typescript.d.mts

@@ -0,0 +1 @@
+export declare function IsTypeScript(value: unknown): value is string;

package/build/guard/typescript.mjs

@@ -0,0 +1,5 @@
+// deno-fmt-ignore-file
+import Guard from 'typebox/guard';
+export function IsTypeScript(value) {
+    return Guard.IsString(value);
+}

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

@@ -1,13 +1,29 @@
 import { Validator } from '../validator.mjs';
 import Type from 'typebox';
+/**
+ * High-performance Json Schema validator that uses library-specific
+ * inference mechanisms. The validator assumes the source library
+ * produces accurate schematics that encode the runtime
+ * representations of its types.
+ *
+ * In TypeBox terminology, this falls under the TUnsafe<T> category.
+ * Preferably, TypeScript types "should" be derived from the
+ * schematics rather than assumed.
+ *
+ * Note:
+ *
+ * Standard JSON Schema does not advertise which Draft versions it
+ * supports, and the resolver is using try/catch resolution. This
+ * should be brought up in RFC feedback, not by me of course, I don't
+ * know anything about Json Schema.
+ */
 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;
+    toJsonSchema(): unknown;
     check(value: unknown): value is Output;
     parse(value: unknown): Output;
     errors(value: unknown): object[];

package/build/json-schema/validator.mjs

@@ -1,7 +1,24 @@
 // deno-fmt-ignore-file
 import { Validator as TBValidator } from 'typebox/compile';
-import { AssertError, ParseError } from '../errors.mjs';
+import { ParseError } from '../errors.mjs';
 import { Validator } from '../validator.mjs';
+/**
+ * High-performance Json Schema validator that uses library-specific
+ * inference mechanisms. The validator assumes the source library
+ * produces accurate schematics that encode the runtime
+ * representations of its types.
+ *
+ * In TypeBox terminology, this falls under the TUnsafe<T> category.
+ * Preferably, TypeScript types "should" be derived from the
+ * schematics rather than assumed.
+ *
+ * Note:
+ *
+ * Standard JSON Schema does not advertise which Draft versions it
+ * supports, and the resolver is using try/catch resolution. This
+ * should be brought up in RFC feedback, not by me of course, I don't
+ * know anything about Json Schema.
+ */
 export class JsonSchemaValidator extends Validator {
     constructor(input) {
         super();
@@ -20,16 +37,12 @@ export class JsonSchemaValidator extends Validator {
     isJsonSchema() {
         return true;
     }
-    asJsonSchema() {
+    toJsonSchema() {
         return this.input;
     }
     // ----------------------------------------------------------------
     // Validation
     // ----------------------------------------------------------------
-    assert(value) {
-        if (!this.validator.Check(value))
-            throw new AssertError(this.errors(value));
-    }
     check(value) {
         return this.validator.Check(value);
     }

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

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

package/build/standard-json-schema/index.mjs

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

package/build/standard-json-schema/resolve.d.mts

@@ -0,0 +1,2 @@
+import { StandardJSONSchemaV1 } from '../_standard/standard-schema.mjs';
+export declare function ResolveJsonSchema(input: StandardJSONSchemaV1): Record<string, unknown>;

package/build/standard-json-schema/resolve.mjs

@@ -0,0 +1,32 @@
+// deno-fmt-ignore-file
+import { Guard } from 'typebox/guard';
+function AsOpenAPI3_0(input) {
+    try {
+        return input['~standard'].jsonSchema.input({ target: 'openapi-3.0' });
+    }
+    catch {
+        return undefined;
+    }
+}
+function AsDraft7(input) {
+    try {
+        return input['~standard'].jsonSchema.input({ target: 'draft-07' });
+    }
+    catch {
+        return undefined;
+    }
+}
+function AsDraft2020_12(input) {
+    try {
+        return input['~standard'].jsonSchema.input({ target: 'draft-2020-12' });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function ResolveJsonSchema(input) {
+    const jsonschema = AsDraft2020_12(input) ?? AsDraft7(input) ?? AsOpenAPI3_0(input);
+    if (Guard.IsUndefined(jsonschema))
+        throw Error(`Vendor '${input['~standard'].vendor}' advertised itself as a Standard JSON Schema but failed to produce a schematic. Submit an issue with the vendor.`);
+    return jsonschema;
+}

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

@@ -0,0 +1,25 @@
+import { StandardJSONSchemaV1, StandardSchemaV1 } from '../_standard/standard-schema.mjs';
+import { Validator } from '../validator.mjs';
+/**
+ * High-performance Json Schema validator that uses library-specific
+ * inference mechanisms. The validator assumes the source library
+ * produces accurate schematics that encode the runtime
+ * representations of its types.
+ *
+ * Note:
+ *
+ * Standard JSON Schema does not advertise which Draft versions it
+ * supports, and the resolver is using try/catch resolution. This
+ * should be brought up in RFC feedback.
+ */
+export declare class StandardJsonSchemaValidator<Input extends StandardJSONSchemaV1 & StandardSchemaV1, Output extends unknown = StandardSchemaV1.InferOutput<Input>> extends Validator<Input, Output> {
+    private readonly input;
+    private readonly validator;
+    constructor(input: Input);
+    schema(): Input;
+    isJsonSchema(): boolean;
+    toJsonSchema(): unknown;
+    check(value: unknown): value is Output;
+    parse(value: unknown): Output;
+    errors(value: unknown): object[];
+}

package/build/standard-json-schema/validator.mjs

@@ -0,0 +1,54 @@
+// deno-fmt-ignore-file
+import { ParseError } from '../errors.mjs';
+import { Validator } from '../validator.mjs';
+import { Validator as TBValidator } from 'typebox/compile';
+import { ResolveJsonSchema } from './resolve.mjs';
+/**
+ * High-performance Json Schema validator that uses library-specific
+ * inference mechanisms. The validator assumes the source library
+ * produces accurate schematics that encode the runtime
+ * representations of its types.
+ *
+ * Note:
+ *
+ * Standard JSON Schema does not advertise which Draft versions it
+ * supports, and the resolver is using try/catch resolution. This
+ * should be brought up in RFC feedback.
+ */
+export class StandardJsonSchemaValidator extends Validator {
+    constructor(input) {
+        super();
+        this.input = input;
+        const schema = ResolveJsonSchema(input);
+        this.validator = new TBValidator({}, schema);
+    }
+    // ----------------------------------------------------------------
+    // Schema
+    // ----------------------------------------------------------------
+    schema() {
+        return this.input;
+    }
+    // ----------------------------------------------------------------
+    // Json Schema
+    // ----------------------------------------------------------------
+    isJsonSchema() {
+        return true;
+    }
+    toJsonSchema() {
+        return this.validator.Type();
+    }
+    // ----------------------------------------------------------------
+    // Validation
+    // ----------------------------------------------------------------
+    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/validator.d.mts

@@ -1,12 +1,11 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import { StandardSchemaV1 } from '../_standard/standard-schema.mjs';
 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;
+    toJsonSchema(): unknown;
     check(value: unknown): value is Output;
     parse(value: unknown): Output;
     errors(value: unknown): object[];

package/build/standard-schema/validator.mjs

@@ -1,5 +1,5 @@
 // deno-fmt-ignore-file
-import { AssertError, ParseError, UnknownError } from '../errors.mjs';
+import { ParseError, UnknownError } from '../errors.mjs';
 import { Validator } from '../validator.mjs';
 export class StandardSchemaValidator extends Validator {
     constructor(input) {
@@ -18,17 +18,12 @@ export class StandardSchemaValidator extends Validator {
     isJsonSchema() {
         return false;
     }
-    asJsonSchema() {
+    toJsonSchema() {
         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);

package/build/static.d.mts

@@ -1,4 +1,4 @@
-import { type StandardSchemaV1 } from '@standard-schema/spec';
+import { type StandardSchemaV1 } from './_standard/standard-schema.mjs';
 import { type Validator } from './validator.mjs';
 import Type from 'typebox';
 type StaticValidator<_Input extends unknown, Output extends unknown> = (Output);

package/build/typescript/validator.d.mts

@@ -7,9 +7,8 @@ export declare class TypeScriptValidator<Input extends string, Schema extends Ty
     constructor(script: Input);
     schema(): Input;
     isJsonSchema(): boolean;
-    asJsonSchema(): unknown;
+    toJsonSchema(): 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

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Validator as TBValidator } from 'typebox/compile';
 import { Validator } from '../validator.mjs';
-import { AssertError, ParseError } from '../errors.mjs';
+import { ParseError } from '../errors.mjs';
 import Type from 'typebox';
 export class TypeScriptValidator extends Validator {
     constructor(script) {
@@ -22,7 +22,7 @@ export class TypeScriptValidator extends Validator {
     isJsonSchema() {
         return true;
     }
-    asJsonSchema() {
+    toJsonSchema() {
         return this.jsonschema;
     }
     // ----------------------------------------------------------------
@@ -31,10 +31,6 @@ export class TypeScriptValidator extends Validator {
     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));

package/build/validator.d.mts

@@ -1,17 +1,15 @@
 /** 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 */
+    /** Returns the schema used to construct 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 */
+    /** True if the validator has a Json Schema representation */
     abstract isJsonSchema(): boolean;
-    /** Returns this validator as Json Schema. */
-    abstract asJsonSchema(): unknown;
+    /** Return the validator Json Schema representation. */
+    abstract toJsonSchema(): unknown;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedriver",
   "description": "Unified Runtime Validation and Inference Driver for TypeScript",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "keywords": [
     "typescript",
     "json-schema",
@@ -14,8 +14,7 @@
     "url": "https://github.com/sinclairzx81/typedriver"
   },
   "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
-    "typebox": "^1.0.53"
+    "typebox": "^1.0.61"
   },
   "type": "module",
   "types": "./build/index.d.mts",
@@ -25,10 +24,18 @@
       "import": "./build/standard-schema/index.mjs",
       "default": "./build/standard-schema/index.mjs"
     },
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
+    },
     "./json-schema": {
       "import": "./build/json-schema/index.mjs",
       "default": "./build/json-schema/index.mjs"
     },
+    "./standard-json-schema": {
+      "import": "./build/standard-json-schema/index.mjs",
+      "default": "./build/standard-json-schema/index.mjs"
+    },
     "./typescript": {
       "import": "./build/typescript/index.mjs",
       "default": "./build/typescript/index.mjs"
@@ -43,9 +50,15 @@
       "standard-schema": [
         "./build/standard-schema/index.d.mts"
       ],
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
       "json-schema": [
         "./build/json-schema/index.d.mts"
       ],
+      "standard-json-schema": [
+        "./build/standard-json-schema/index.d.mts"
+      ],
       "typescript": [
         "./build/typescript/index.d.mts"
       ],

package/readme.md

@@ -2,143 +2,158 @@
 
 <h1>TypeDriver</h1>
 
-<p>Unified Runtime Validation and Inference Driver for TypeScript</p>
+<p>Integration Driver for High Performance Runtime Validation</p>
 
 <img src="typedriver.png" />
 
 <br />
 <br />
 
+[![npm version](https://badge.fury.io/js/typedriver.svg)](https://badge.fury.io/js/typedriver)
+[![Downloads](https://img.shields.io/npm/dm/typedriver.svg)](https://www.npmjs.com/package/typedriver)
 [![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>
 
+## Install
 
-## Example
+```bash
+$ npm install typedriver
+```
 
-Compile, Infer and Parse
+## Example
 
 ```typescript
-import { compile, type Static } from 'typedriver'
-
-// Compile
+import { compile } from 'typedriver'
 
-const Vector3 = compile(`{
-  x: number
-  y: number
+const Vec3 = 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
-})                                                  // } = ...
+}`)
+
+const normal = Vec3.parse({
+  x: 0, 
+  y: 1,
+  z: 0
+})
 ```
 
 ## 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.
+TypeDriver is a runtime type system and integration driver for web frameworks that need to support type inference and validation for TypeScript, Json Schema, and Standard Schema. It includes a high-performance Json Schema validation compiler, an integrated TypeScript engine, and seamless integration support for Standard Schema libraries.
+
+TypeDriver supports Json Schema drafts 3 through 2020-12. It provides advanced type inference support for both Json Schema and TypeScript DSL definitions as standard. It uses TypeBox as a foundation for high performance runtime validation, and Standard Schema for cross-library compatibility.
 
 License MIT
 
 ## Contents
 
 - [Overview](#Overview)
+- [Framework](#Framework)
 - [Compile](#Compile)
-- [Validator](#Validator)
-  - [Assert](#Assert)
   - [Check](#Check)
   - [Parse](#Parse)
   - [Errors](#VaErrorslidator)
 - [Static](#Static)
-- [Schema](#Schema)
+- [Reflect](#Schema)
 - [Contribute](#Contribute)
 
+## Framework
+
+TypeDriver is designed specifically for framework developers who need to develop systems to host multiple type safe libraries on framework interfaces. It offers a simple infrastructure to connect type inference and validation to the framework, and is unopinionated with regards to framework design.
+
+[Typescript](https://www.typescriptlang.org/play/?target=99&module=7#code/PTAEFpK6dv4YyAoEoAiBTAzgSwOYB2qYSZ5FcyADgPbYAuAFAOTAsA0oA3sqKACNaAEwCeALlAADXv34APSYQCuAWwGYAThz5yJoFeq065oAF5K1GzboC+U5La5NNmAI7KcDAJSgAvAB8PLoAxrSEjDyg8lyiXGagtv6grh5eAHRCYqBoDKLUmODYAIYAZpgAhI7eyCQQlA2N8HUAYprFqpgA7rSaANZ1TUPDyLiqdJoMUXkFoADKDMUMuCFcYeO4ADaYiaClmrSqoCwzmMKauABuWiy1mPITU7iEDFqlxSE7AEq0yq8A8tRluFsAAeABCIlEoHur0IwmwoGUhD6hFoXUIyWRqPRhCCskEUMkkLEjmQ90eoFOoB+f0wAGFiptNgIPn1QQAFJYACxh8jhCNAjAuhHwXEBwIifIFiNpAKBuBBQT8oCYuhc7k8jEk3CRmk2ki5DG5XCy+gWSxWoIlioiAG0WGaWABdIK2XyBUCXWi4YTIGoU3pTUrIkKS0B0RicnnSzDwxHC55i0BhCJTG0g2Pxmm-eWS7BcXSM5mskJ9ZJyhlMlls6PG8UKpXIAJMag8w08ri0RsRSQZiJraulvqSYs1su+AmpyJmgD6lyZvqWvWS62oW0wTG7+YdTudNX4uREtEk6TPoDG1G2nReKVzO02tHwKzJQA) | [Json Schema](https://www.typescriptlang.org/play/?target=99&module=7#code/PTAEFpK6dv4YyAoEoAiBTAzgSwOYB2qYSZ5FcyADgPbYAuAFAOTAsA0oA3sqKACNaAEwCeALh59+oBqOqZJLWgIBWmAMYNO0-gCdMARwCuuA8MkBtFgA9OoFqPssAXiwC6HXaGp7aCvQZcHEleGRkbUNl5RQdCYwBbAUw9FlAAXy9w-gkeaIUleKSUtMzvfhcouQK4xOTUjKyZdOkWzNAmAxMcBgBKUABeAD4pfg1aQkY8my5RLhcMwdAu4x6AOiExUDRqzHBsAEMAM0wAQmR03uQSCEo7+-gbgDE9A4TMAHdaPQBrG4eAYDkLgEnRAnldqAAMoMA5BDRccag3AAG0wiyOfgSDl2wj0uAAbiVrpgbGCGKBcIQGCkjgcNOiAEq0Yw0gDy1CCE2wAB4AEIiUSgUk0wjCbCgYyEH6EWgfQhLKUyuWEEZhQSCyQCsQXZCk8n5JksmkAYQOKJRAnpPx5AAU4QALYU2UXi0CMfGEfBcDlcybO10S5mszC+3DckYDDrSTpGVaMKLGPQoyT2hgOribXIwuG4DQ8sPc6xZjwjS6DEYE2i4YTIK7674Uo5SrThhV0Rh2x0BzBiiUeqne0DjSYUwv+kW9t3B9mctvYLjSM0Wq0aH5LGeYZeW61d9M+ucR5BDJjUR2px1cfx+7CSccL4fmndryTb1c-frqkdTLMAfQJ5o1nC3xLEi1CopgTDXvOxaCh4Vz8DsIi0JIaxoZSoJou81LLMa6IorQ+B5rqQA) | [Standard Schema](https://www.typescriptlang.org/play/?target=99&module=7#code/PTAEFpK6dv4YyAoEoAiBTAzgSwOYB2qYSZ5FcyuAtgA4D2ATgC6gBUoAhtqAF6gAZkwY1QAcj4MAJuOTJG2FgApxwcQBpQAb2ShQAIxkBPAFz8AdAwMArTAGMVu-foAe5vhcIBXGgcxMygCUGnouZpY+fgHBoS78Hl6+-oEhYQC+QcjpWspMmACO3jgsQaAAvAB8OmH2DIRKOqCuWsZaAukVoPlFJRZG0sagaCzGdJjg2FyCmACE2VkkEJQrq-BLAGJMXDSYAO7MANZLa6dn1PTMbNqgo+OgAMosXCy49lp19LgANpigncJRBI7phpExcAA3AJyZCYVyMVigXCEFgBQRcex-ABKDG8qIA8nRXvVsAAeABCJlAcNRhGkvG8hEOhAYe0IXUZzNZhGqzkMJnMlMG2Vh8KutzG2NxqIAwlxvt8DBjDqSAAovAAW1NctPpoCU4MI+C0hOJDW1ut4OLxmFNuBJ1XKoGUYTyhWKSnMN28TG+5nVLA1WgGESeLzepLtJIA2uIQ+IALrVTIVaoQhi4aTILJwhFsQSMxz29mKFhqzUWzB03gG5HG0B1BpsKPmmlVvXWglE4vYLRhOUKpX2Q5dTuYAeK5XlwMm7sO5CVZR0TX+zVaBhzhrmFu9hvyyfD8wToeHMp8xuNEMAfQh8szL2YXU+dB+mGUG7N2Fj8YTWX0IxkBhzAsECkXoX5dhRbppT+b4GHwN4RSAA)
+
+```typescript
+post('/', {
+  body: `{
+    x: number,
+    y: number,
+    z: number
+  }`
+}, (request) => {
+  const { x, y, z } = request.body // type-safe!
+})
+```
+
+The above design is achieved in a few lines of code.
+
+```typescript
+import { type Static, compile } from 'typedriver'
+
+export interface RouteOptions<Body extends unknown = unknown> {
+  body: Body
+}
+export type RouteCallback<Path extends string, Options extends RouteOptions> = (
+  (request: { url: Path, body: Static<Options['body']> }) => void
+)
+export function post<Path extends string, const Options extends RouteOptions, 
+  Callback = RouteCallback<Path, Options>
+>(path: Path, options: Options, callback: Callback) {
+  const body_validator = compile(options['body'])
+  // todo: ... implement route logic
+}
+```
+
+
 ## 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.
+TypeDriver consists of a singular compile(...) function that accepts either a TypeScript, Json Schema and Standard Schema definition and returns an optimized Validator.
 
 ```typescript
 import { compile } from 'typedriver'
 ```
 
-Use the compile function can compile TypeScript types ...
+Pass TypeScript definitions via strings. | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYwuYAbApnAvnAMyjTgHIYBPMLAEymADcspSAoV1AOwGd4A1LMhjQAzHAC8KNGExYAFAAMErOHAAeALjicAriABGzFXApbdBo6oBeZvYaitcCgJSq37j56-ef7gPR+Ujz8gsJQIlp8AIYYwDRRYQA8AHSpADSIxr7ZObluAW6a2nbMaVl5FZX5gaqmxRZQZVXNlQXWtg1NLd3ZBbgAfOxcvHCQ3MAwwBCcEnACQqLJYFFQ3PJIxkUADF11AIxdNnBbjs5AA)
 
 ```typescript
-const Vector3 = compile(`{
+const Vec3 = compile(`{
   x: number
   y: number
   z: number
-}`)                                                // const Vector3: Validator<..., {
-                                                   //   x: number,
-                                                   //   y: number,
-                                                   //   z: number,
-                                                   // }>
+}`)
 ```
 
-... or Json Schema schematics
+... or Json Schema | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYwuYAbApnAvnAMyjTgHIYBPMLAEymADcspSAoV1AOwGd4A1LMhjQAzHAC8KNGExYAFEjhLlK1WtUB6DVJ79BwqCIBccPgEMMwGmYMAeAHSOANIlZLK1E6QgAjAFb6pC7qIaFhWsoAHiacAK4gPsxObnBQWACOscBpNCYA2qSRQWQUxaQAXqQAusFhdXARShQx8YlQyUpgxNSwwFjcJor1w+HaSuUtCcwpStGIcB5YXnFTLHi1I6ERuAB8M3DN84vLrcyk6-sTR1RLZCtt57gpT7gAlOxcvHCQ3MAwwBBOBJTPpRPYwGYoNx5EgUnMAAwdA4mACMSKu8NYbyAA)
 
 ```typescript
-const Vector3 = compile({                           // const Vector3: Validator<..., {
-  type: 'object',                                   //   x: number,
-  required: ['x', 'y', 'z'],                        //   y: number,
-  properties: {                                     //   z: number
-    x: { type: 'number' },                          // }>
+const Vec3 = compile({ 
+  type: 'object',
+  required: ['x', 'y', 'z'],
+  properties: {
+    x: { type: 'number' },
     y: { type: 'number' },
     z: { type: 'number' }
   }
 })
 ```
 
-... or libraries that implement Standard Schema.
+... or libraries that implement Standard Schema | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYwuYAbApnAvnAMyjTgHIYBPMLAEymADcspSAoV0SWOAKjgEMAznABehYiDIiINNq1QA7QfABqWZDGgBmOAF4UaMJiwAKEQDoIAIwBW6mCaRxnL12+cB6DwaWr72gC44FX4MYBp+TSgAHnM4gBpEVmcADyCLBQBXECtmEwBKRPdiktK3Lxc0uCyc5njkuAp08xrcqAKisq7uuArnJurstvrnEWbWvMKe6dK+0SCJqFZcfPyZ9Y3e71wAPnZFZThIQWAYYAgFPWD-KC1zMH4oQVMkBqqABhHGoIBGL7G4O9lvkgA)
 
 ```typescript
-import * z from 'zod'
+import * as 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
-}))                                                 // }>
+const Vec3 = compile(z.object({ 
+  x: z.number(),  
+  y: z.number(), 
+  z: 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
+## Validator
 
-Vector3.assert(value)                               
-```
+The compile(...) function returns Validator instances to Check, Parse and report Errors for JavaScript values.
 
 ### Check
 
-The check(...) returns a safe boolean result.
+The check(...) returns a boolean result.
 
 ```typescript
-// Vector3.check(value: unknown): value is Vector3
+// Vec3.check(value: unknown): value is Vec3
 
-if(Vector3.check(value)) {
+if(Vec3.check(value)) {
 
   const { x, y, z } = value // safe
 }
@@ -146,69 +161,86 @@ if(Vector3.check(value)) {
 
 ### Parse
 
-The parse(...) function checks and returns a value and throws on error.
+The parse(...) function returns if valid, otherwise throws.
 
 ```typescript
-// Vector3.parse(value: unknown): Vector3
+// Vec3.parse(value: unknown): Vec3
 
-const { x, y, z } = Vector3.parse(value)                 
+const { x, y, z } = Vec3.parse(value)                 
 ```
 
 ### Errors
 
-The errors(...) function returns validation errors for a value.
+The errors(...) function returns diagnostics (use only after failed check)
 
 ```typescript
-// Vector3.errors(value: unknown): object[]
+// Vec3.errors(value: unknown): object[]
 
-const errors = Vector3.errors(value)              
+const errors = Vec3.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.
+The Static type that can infer TypeScript, Json Schema and Standard Schema | [Example](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAbzjAnmApnAyjAhjYAYzgF84AzKCEOAclQwBMpgA3dKWgKC4Hpe4ASQB25DsjToAzhSo1cAGwXIAFsGEBzKQEIeDTAEE4AXmx4ChADwADJFzhwAHgC44wgK4gARhwA09uBRXD28-AIAvYM8fKC4SawA+PUk4ACETM3wiSwQA-VdaCC8AK3RCGFp-Byh0AEd3YBrGVwBtWkdKuhRO2nDaAF0quDAqDFhgaVdchwcXRAkMApCY2lIhhyD5-LpljlWSdbhIrckl6L21gJI4pK5QSFg4ACo4XBlw2Wo6cIhGbi5CBBhFJ4ABhDLhAB0RVK5QAFNMnK4obsoHCAJRDTYo85ozERZGQ1EY-wkdFcfRwcGmHBZKz6CDkKm3IA)
 
 ```typescript
-import { compile, type Static } from 'typedriver'
+import { type Static } from 'typedriver'
 
-const Vector = compile(`{ 
+// Infer types from all things!
+
+type A = Static<`{ 
   x: number,
   y: number,
   z: number
-}`)
+}`>
+
+type B = Static<{
+  type: 'object',
+  required: ['x', 'y', 'z'],
+  properties: {
+    x: { type: 'number' },
+    y: { type: 'number' },
+    z: { type: 'number' },
+  }
+}>
+
+import * as z from 'zod'
+
+const C = z.object({
+  x: z.number(),
+  y: z.number(),
+  z: z.number(),
+})
+type C = Static<typeof C>
+
 
-type Vector = Static<typeof Vector>                 // type Vector = {
-                                                    //   x: number
-                                                    //   y: number
-                                                    //   z: number
-                                                    // }
 ```
 
-## Schema
+## Reflect
 
-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.
+Validators can reflect back a Json Schema representation if the underlying type supports it. This is true for all TypeScript and Json Schema source types. Reflect can be used for OpenAPI metadata publishing, or RPC systems that need to publish Json based IDL (interface definition language) to remote callers. Validators provide two functions for this.
 
 ```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.toJsonSchema()    // 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.
+```
+The source type used for compilation can also be returned via
 
-validator.schema()          // Returns the schema that was passed to compile. This 
-                            // can be used to manually transform the schema if 
-                            // isJsonSchema() returns false.
+```typescript
+validator.schema()          // will return the schematic used for compile.
 ```
 
 ## 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.
+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.

package/build/guard.d.mts

@@ -1,5 +0,0 @@
-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;