feat(framework): add class-validator support

packages/framework/package.json

@@ -170,9 +170,13 @@
     "@sveltejs/kit": ">=1.27.3",
     "@vercel/node": ">=2.15.9",
     "aws-lambda": ">=1.0.7",
+    "class-transformer": ">=0.5.1",
+    "class-validator": ">=0.14.0",
+    "class-validator-jsonschema": ">=5.0.0",
     "express": ">=4.19.2",
     "h3": ">=1.8.1",
     "next": ">=12.0.0",
+    "reflect-metadata": ">=0.2.2",
     "zod": ">=3.0.0",
     "zod-to-json-schema": ">=3.0.0"
   },
@@ -201,6 +205,18 @@
     "next": {
       "optional": true
     },
+    "class-transformer": {
+      "optional": true
+    },
+    "class-validator": {
+      "optional": true
+    },
+    "class-validator-jsonschema": {
+      "optional": true
+    },
+    "reflect-metadata": {
+      "optional": true
+    },
     "zod": {
       "optional": true
     },
@@ -219,11 +235,15 @@
     "@types/sanitize-html": "2.11.0",
     "@vercel/node": "^2.15.9",
     "aws-lambda": "^1.0.7",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "class-validator-jsonschema": "^5.0.1",
     "express": "^4.19.2",
     "h3": "^1.11.1",
     "madge": "^8.0.0",
     "next": "^13.5.4",
     "prettier": "^3.2.5",
+    "reflect-metadata": "^0.2.2",
     "ts-node": "^10.9.2",
     "tsup": "^8.0.2",
     "tsx": "4.16.2",

packages/framework/src/resources/workflow/discover-custom-step-factory.ts

@@ -6,6 +6,7 @@ import type {
   StepType,
   StepOutput,
   StepOptions,
+  FromSchema,
   Schema,
 } from '../../types';
 import { transformSchema } from '../../validators';

packages/framework/src/types/schema.types/base.schema.types.test-d.ts

@@ -37,6 +37,15 @@ describe('FromSchema', () => {
 
     expectTypeOf<FromSchema<typeof testZodSchema>>().toEqualTypeOf<{ foo: string; bar?: string }>();
   });
+
+  it('should infer a Class Schema type', () => {
+    class TestSchema {
+      foo: string = 'bar';
+      bar?: string;
+    }
+
+    expectTypeOf<FromSchema<typeof TestSchema>>().toEqualTypeOf<{ foo: string; bar?: string }>();
+  });
 });
 
 describe('FromSchemaUnvalidated', () => {
@@ -74,4 +83,13 @@ describe('FromSchemaUnvalidated', () => {
 
     expectTypeOf<FromSchemaUnvalidated<typeof testZodSchema>>().toEqualTypeOf<{ foo?: string; bar?: string }>();
   });
+
+  it('should infer a Class Schema type', () => {
+    class TestClassSchema {
+      foo?: string = 'bar';
+      bar?: string;
+    }
+
+    expectTypeOf<FromSchemaUnvalidated<typeof TestClassSchema>>().toEqualTypeOf<{ foo?: string; bar?: string }>();
+  });
 });

packages/framework/src/types/schema.types/base.schema.types.ts

@@ -1,10 +1,11 @@
 import type { InferJsonSchema, JsonSchemaMinimal } from './json.schema.types';
 import type { InferZodSchema, ZodSchemaMinimal } from './zod.schema.types';
+import type { InferClassValidatorSchema, ClassValidatorSchema } from './class.schema.types';
 
 /**
  * A schema used to validate a JSON object.
  */
-export type Schema = JsonSchemaMinimal | ZodSchemaMinimal;
+export type Schema = JsonSchemaMinimal | ZodSchemaMinimal | ClassValidatorSchema;
 
 /**
  * Main utility type for schema inference
@@ -14,6 +15,8 @@ export type Schema = JsonSchemaMinimal | ZodSchemaMinimal;
  */
 type InferSchema<T extends Schema, Options extends { validated: boolean }> =
   | InferJsonSchema<T, Options>
+  | InferZodSchema<T, Options>
+  | InferClassValidatorSchema<T, Options>
   | InferZodSchema<T, Options>;
 
 /**

packages/framework/src/types/schema.types/class.schema.types.test-d.ts

@@ -0,0 +1,42 @@
+import { describe, expectTypeOf, it } from 'vitest';
+import { InferClassValidatorSchema } from './class.schema.types';
+
+describe('ClassSchema types', () => {
+  class TestSchema {
+    foo: string = 'bar';
+    bar?: string;
+  }
+
+  describe('validated data', () => {
+    it('should compile when the expected properties are provided', () => {
+      expectTypeOf<InferClassValidatorSchema<typeof TestSchema, { validated: true }>>().toEqualTypeOf<{
+        foo: string;
+        bar?: string;
+      }>();
+    });
+
+    it('should not compile when the schema is not a ClassSchema', () => {
+      expectTypeOf<InferClassValidatorSchema<string, { validated: true }>>().toEqualTypeOf<never>();
+    });
+
+    it('should not compile when a property does not match the expected type', () => {
+      // @ts-expect-error - Type 'number' is not assignable to type 'string'.
+      expectTypeOf<InferClassValidatorSchema<typeof TestSchema, { validated: true }>>().toEqualTypeOf<{
+        foo: number;
+      }>();
+    });
+  });
+
+  describe('unvalidated data', () => {
+    /**
+     * TODO: Support accessing defaulted properties when Typescript supports it.
+     */
+    it.skip('should keep the defaulted properties optional', () => {
+      // @ts-expect-error - Type 'undefined' is not assignable to type 'string'.
+      expectTypeOf<InferClassValidatorSchema<typeof TestSchema, { validated: false }>>().toEqualTypeOf<{
+        foo?: string;
+        bar?: string;
+      }>();
+    });
+  });
+});

packages/framework/src/types/schema.types/class.schema.types.ts

@@ -0,0 +1,44 @@
+import { Prettify } from '../util.types';
+
+/**
+ * A type that represents a class.
+ */
+export type ClassValidatorSchema<T = unknown> = new (...args: unknown[]) => T;
+
+/**
+ * Extract the properties of a class type.
+ */
+export type ClassPropsInfer<T extends ClassValidatorSchema> =
+  T extends ClassValidatorSchema<infer R> ? Prettify<R> : never;
+
+/**
+ * Infer the data type of a ClassValidatorSchema.
+ *
+ * @param T - The ClassValidatorSchema to infer the data type of.
+ * @param Options - Configuration options for the type inference. The `validated` flag determines whether the schema has been validated. If `validated` is true, all properties are required unless specified otherwise. If false, properties with default values are optional.
+ *
+ * @returns The inferred type.
+ *
+ * @example
+ * ```ts
+ * class MySchema {
+ *   @IsString()
+ *   @IsNotEmpty()
+ *   name: string;
+ *
+ *   @IsEmail()
+ *   @IsOptional()
+ *   email?: string;
+ * }
+ *
+ * // has type { name: string, email?: string }
+ * type MySchema = InferClassValidatorSchema<typeof MySchema, { validated: true }>;
+ * ```
+ */
+export type InferClassValidatorSchema<T, Options extends { validated: boolean }> = T extends ClassValidatorSchema
+  ? Options['validated'] extends true
+    ? ClassPropsInfer<T>
+    : // ClassSchema doesn't support default properties, so the resulting type
+      // will not have default properties set to optional.
+      ClassPropsInfer<T>
+  : never;

packages/framework/src/types/schema.types/index.ts

@@ -1,3 +1,4 @@
 export type { JsonSchema } from './json.schema.types';
 export type { ZodSchemaMinimal, ZodSchema } from './zod.schema.types';
+export type { ClassValidatorSchema } from './class.schema.types';
 export type { Schema, FromSchema, FromSchemaUnvalidated } from './base.schema.types';

packages/framework/src/validators/base.validator.ts

@@ -1,9 +1,18 @@
-import type { FromSchema, FromSchemaUnvalidated, Schema, JsonSchema, ZodSchema } from '../types/schema.types';
+import type {
+  FromSchema,
+  FromSchemaUnvalidated,
+  Schema,
+  JsonSchema,
+  ZodSchema,
+  ClassValidatorSchema,
+} from '../types/schema.types';
 import type { ValidateResult } from '../types/validator.types';
 import { JsonSchemaValidator } from './json-schema.validator';
 import { ZodValidator } from './zod.validator';
+import { ClassValidatorValidator } from './class-validator.validator';
 
 const zodValidator = new ZodValidator();
+const classValidatorValidator = new ClassValidatorValidator();
 const jsonSchemaValidator = new JsonSchemaValidator();
 
 /**
@@ -28,6 +37,8 @@ export const validateData = async <
    */
   if (await zodValidator.canHandle(schema)) {
     return zodValidator.validate(data, schema as ZodSchema);
+  } else if (await classValidatorValidator.canHandle(schema)) {
+    return classValidatorValidator.validate(data, schema as ClassValidatorSchema);
   } else if (await jsonSchemaValidator.canHandle(schema)) {
     return jsonSchemaValidator.validate(data, schema as JsonSchema);
   }
@@ -44,6 +55,8 @@ export const validateData = async <
 export const transformSchema = async (schema: Schema): Promise<JsonSchema> => {
   if (await zodValidator.canHandle(schema)) {
     return zodValidator.transformToJsonSchema(schema as ZodSchema);
+  } else if (await classValidatorValidator.canHandle(schema)) {
+    return classValidatorValidator.transformToJsonSchema(schema as ClassValidatorSchema);
   } else if (await jsonSchemaValidator.canHandle(schema)) {
     return jsonSchemaValidator.transformToJsonSchema(schema as JsonSchema);
   }