@decs/typeschema - npm Package Compare versions

Comparing version 0.4.0 to 0.5.0

dist/adapters/arktype.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { Type } from 'arktype';
-interface ArkTypeResolver extends TypeSchemaResolver {
+interface ArkTypeResolver extends Resolver {
     base: Type<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends Type ? this['schema']['inferIn'] : never;

dist/adapters/function.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 type FunctionSchema<T = unknown> = (data: unknown) => Promise<T> | T;
-interface FunctionResolver extends TypeSchemaResolver {
+interface FunctionResolver extends Resolver {
     base: FunctionSchema<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends FunctionSchema ? keyof this['schema'] extends never ? Awaited<ReturnType<this['schema']>> : never : never;

dist/adapters/io-ts.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { Any, OutputOf, Type, TypeOf } from 'io-ts';
-interface IoTsResolver extends TypeSchemaResolver {
+interface IoTsResolver extends Resolver {
     base: Type<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends Any ? OutputOf<this['schema']> : never;

dist/adapters/joi.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { AnySchema } from 'joi';
-interface JoiResolver extends TypeSchemaResolver {
+interface JoiResolver extends Resolver {
     base: AnySchema<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends AnySchema<infer T> ? T : never;

dist/adapters/runtypes.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { Runtype, Static } from 'runtypes';
-interface RuntypesResolver extends TypeSchemaResolver {
+interface RuntypesResolver extends Resolver {
     base: Runtype<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends Runtype ? Static<this['schema']> : never;

dist/adapters/superstruct.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { Infer, Struct } from 'superstruct';
-interface SuperstructResolver extends TypeSchemaResolver {
+interface SuperstructResolver extends Resolver {
     base: Struct<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends Struct<any, any> ? Infer<this['schema']> : never;

dist/adapters/typebox.d.ts

@@ -1,2 +0,2 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { Static, TSchema } from '@sinclair/typebox';
@@ -6,3 +6,3 @@ type TypeBoxSchema<T> = TSchema & {
 };
-interface TypeBoxResolver extends TypeSchemaResolver {
+interface TypeBoxResolver extends Resolver {
     base: TypeBoxSchema<this['type']>;
@@ -9,0 +9,0 @@ input: this['schema'] extends TSchema ? Static<this['schema']> : never;

dist/adapters/yup.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { InferType, Schema } from 'yup';
-interface YupResolver extends TypeSchemaResolver {
+interface YupResolver extends Resolver {
     base: Schema<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends Schema ? InferType<this['schema']> : never;

dist/adapters/zod.d.ts

@@ -1,4 +0,4 @@
-import type { TypeSchemaResolver } from '../resolver';
+import type { Resolver } from '../resolver';
 import type { input, output, ZodSchema } from 'zod';
-interface ZodResolver extends TypeSchemaResolver {
+interface ZodResolver extends Resolver {
     base: ZodSchema<this['type']>;
@@ -5,0 +5,0 @@ input: this['schema'] extends ZodSchema ? input<this['schema']> : never;

dist/index.d.ts

@@ -1,8 +0,6 @@
-import type { Schema } from './registry';
 import type { InferOutput } from './resolver';
-import type { ValidationIssue } from './schema';
+import type { Schema, ValidationIssue } from './schema';
 import type { IfDefined } from './utils';
-export type { Schema } from './registry';
-export type { ValidationIssue } from './schema';
-export type Infer<TSchema extends Schema> = Schema extends TSchema ? TSchema extends Schema<infer T> ? T : never : {
+export type { Schema, ValidationIssue } from './schema';
+export type Infer<TSchema extends Schema> = {
     [K in keyof TypeSchemaRegistry]: IfDefined<InferOutput<TypeSchemaRegistry[K], TSchema>>;
@@ -16,1 +14,3 @@ }[keyof TypeSchemaRegistry];
 export declare function assert<TSchema extends Schema>(schema: TSchema, data: unknown): Promise<Infer<TSchema>>;
+export declare function createAssert<TSchema extends Schema>(schema: TSchema): (data: unknown) => Promise<Infer<TSchema>>;
+import './adapters';

dist/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = exports.validate = void 0;
+exports.createAssert = exports.assert = exports.validate = void 0;
 const wrap_1 = require("./wrap");
@@ -19,1 +19,6 @@ async function validate(schema, data) {
 exports.assert = assert;
+function createAssert(schema) {
+    return async (data) => assert(schema, data);
+}
+exports.createAssert = createAssert;
+require("./adapters");

dist/registry.d.ts

 import type { Infer } from '.';
 import type { InferSchema } from './resolver';
-import type { TypeSchema } from './schema';
-import type { IfDefined } from './utils';
-export type Schema<T = any> = {
-    [K in keyof TypeSchemaRegistry]: IfDefined<InferSchema<TypeSchemaRegistry[K], T>>;
-}[keyof TypeSchemaRegistry];
+import type { Schema, TypeSchema } from './schema';
 export type Adapter = <TSchema extends Schema>(schema: TSchema) => Promise<TypeSchema<Infer<TSchema>> | null>;
 export declare const adapters: Array<Adapter>;
 export declare function register<TKey extends keyof TypeSchemaRegistry>(coerce: <TSchema extends Schema>(schema: TSchema) => Promise<InferSchema<TypeSchemaRegistry[TKey], Infer<TSchema>> | null>, wrap: <T>(schema: InferSchema<TypeSchemaRegistry[TKey], T>) => Promise<TypeSchema<T>>): void;
-import './adapters';

dist/registry.js

@@ -12,2 +12,1 @@ "use strict";
 exports.register = register;
-require("./adapters");

dist/resolver.d.ts

@@ -1,2 +0,2 @@
-export interface TypeSchemaResolver<TSchema = unknown> {
+export interface Resolver<TSchema = unknown> {
     type: unknown;
@@ -8,10 +8,10 @@ schema: TSchema;
 }
-export type InferInput<TResolver extends TypeSchemaResolver, TSchema> = (TResolver & {
+export type InferInput<TResolver extends Resolver, TSchema> = (TResolver & {
     schema: TSchema;
 })['input'];
-export type InferOutput<TResolver extends TypeSchemaResolver, TSchema> = (TResolver & {
+export type InferOutput<TResolver extends Resolver, TSchema> = (TResolver & {
     schema: TSchema;
 })['output'];
-export type InferSchema<TResolver extends TypeSchemaResolver, T> = (TResolver & {
+export type InferSchema<TResolver extends Resolver, T> = (TResolver & {
     type: T;
 })['base'];

dist/schema.d.ts

@@ -0,1 +1,6 @@
+import type { InferSchema } from './resolver';
+import type { IfDefined } from './utils';
+export type Schema = {
+    [K in keyof TypeSchemaRegistry]: IfDefined<InferSchema<TypeSchemaRegistry[K], any>>;
+}[keyof TypeSchemaRegistry];
 export type TypeSchema<T = unknown> = {
@@ -2,0 +7,0 @@ validate(data: unknown): Promise<{

dist/wrap.d.ts

 import type { Infer } from '.';
-import type { Schema } from './registry';
-import type { TypeSchema } from './schema';
+import type { Schema, TypeSchema } from './schema';
 export declare const cachedWrappedSchemas: Map<Schema, TypeSchema>;
 export declare function wrapCached<TSchema extends Schema>(schema: TSchema): TypeSchema<Infer<TSchema>> | null;
 export declare function wrap<TSchema extends Schema>(schema: TSchema): Promise<TypeSchema<Infer<TSchema>>>;

package.json

 {
   "name": "@decs/typeschema",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Universal adapter for schema validation",
@@ -5,0 +5,0 @@ "keywords": [

README.md

@@ -52,5 +52,5 @@ <div id="header">
 // Use your favorite validation library, e.g. `zod`, `arktype`, `typia`
-const schema: Schema<string> = z.string();
-const schema: Schema<string> = type('string');
-const schema: Schema<string> = typia.createAssert<string>();
+const schema: Schema = z.string();
+const schema: Schema = type('string');
+const schema: Schema = typia.createAssert<string>();
 
@@ -67,2 +67,7 @@ // Extracts the schema type
 await validate(schema, 123); // {issues: [`ValidationIssue`]}
+
+// Returns an assertion function for a specific schema
+const assertString = createAssert(schema);
+await assertString('123'); // '123'
+await assertString(123); // throws `ValidationIssue`
 ```
@@ -74,10 +79,6 @@
 
-- `Schema<T>`
+- `Schema`
 
-  Generic interface for schemas<br />An union of the schema types of all supported validation libraries
+  Generic interface for schemas<br />An union of the schema types of all supported libraries
 
-- `Infer<TSchema extends Schema>`
-
-  Extracts the equivalent TypeScript type of a schema
-
 - `ValidationIssue`
@@ -87,2 +88,6 @@
 
+- `Infer<TSchema extends Schema>`
+
+  Extracts the output type of a schema
+
 #### Functions
@@ -96,3 +101,3 @@
     data: unknown,
-  ): Promise<Infer<Schema>>
+  ): Promise<Infer<TSchema>>
   ```
@@ -113,2 +118,12 @@
 
+- `createAssert(schema)`
+
+  ```ts
+  createAssert<TSchema extends Schema>(
+    schema: TSchema,
+  ): (data: unknown) => Promise<Infer<TSchema>>
+  ```
+
+  Returns an assertion function for a specific schema
+
 ## Coverage
@@ -115,0 +130,0 @@

No alert changes

Improved metrics

Total package byte prevSize

37912

increased by0.7%

Lines of code

707

increased by0.43%

Number of lines in readme file

162

increased by10.2%

No dependency changes