@sapporta/rest-core 3.52.1

package/src/lib/server.spec.ts

@@ -0,0 +1,163 @@
+import {
+  initContract,
+  TsRestResponseValidationError,
+  validateResponse,
+} from '..';
+import { z } from 'zod';
+
+const c = initContract();
+const contract = c.router(
+  {
+    plainResponse: {
+      method: 'GET',
+      path: `/plain`,
+      responses: {
+        200: c.type<{ foo: string }>(),
+      },
+    },
+    zodResponse: {
+      method: 'GET',
+      path: '/zod',
+      responses: {
+        200: z.object({
+          foo: z.string().transform((val) => val.toUpperCase()),
+        }),
+      },
+    },
+    overrideCommonResponse: {
+      method: 'GET',
+      path: '/override-common',
+      responses: {
+        200: z.object({
+          foo: z.string(),
+        }),
+        400: z.object({
+          foo: z.string(),
+        }),
+      },
+    },
+  },
+  {
+    commonResponses: {
+      400: z.object({
+        message: z.literal('Bad Request'),
+      }),
+      404: z.object({
+        message: z.literal('Not Found'),
+      }),
+    },
+  },
+);
+
+describe('server', () => {
+  it('succeeds validation on plain type', () => {
+    const validatedResponse = validateResponse({
+      appRoute: contract.plainResponse,
+      response: {
+        status: 200,
+        body: { anything: 'foo' },
+      },
+    });
+
+    expect(validatedResponse).toEqual({
+      status: 200,
+      body: { anything: 'foo' },
+    });
+  });
+
+  it('succeeds validation on non-existent status code', () => {
+    const validatedResponse = validateResponse({
+      appRoute: contract.plainResponse,
+      response: {
+        status: 500,
+        body: { anything: 'foo' },
+      },
+    });
+
+    expect(validatedResponse).toEqual({
+      status: 500,
+      body: { anything: 'foo' },
+    });
+  });
+
+  it('succeeds validation on zod response', () => {
+    const validatedResponse = validateResponse({
+      appRoute: contract.zodResponse,
+      response: {
+        status: 200,
+        body: { foo: 'bar' },
+      },
+    });
+
+    expect(validatedResponse).toEqual({
+      status: 200,
+      body: { foo: 'BAR' },
+    });
+  });
+
+  it('fails validation on zod response', () => {
+    expect(() => {
+      validateResponse({
+        appRoute: contract.zodResponse,
+        response: {
+          status: 200,
+          body: { bar: 'foo' },
+        },
+      });
+    }).toThrow(TsRestResponseValidationError);
+  });
+
+  it('succeeds validation on zod common response', () => {
+    const validatedResponse = validateResponse({
+      appRoute: contract.plainResponse,
+      response: {
+        status: 400,
+        body: { message: 'Bad Request' },
+      },
+    });
+
+    expect(validatedResponse).toEqual({
+      status: 400,
+      body: { message: 'Bad Request' },
+    });
+  });
+
+  it('fails validation on zod common response', () => {
+    expect(() => {
+      validateResponse({
+        appRoute: contract.plainResponse,
+        response: {
+          status: 400,
+          body: { message: 'not bad request' },
+        },
+      });
+    }).toThrow(TsRestResponseValidationError);
+  });
+
+  it('succeeds validation on overridden zod common response', () => {
+    const validatedResponse = validateResponse({
+      appRoute: contract.overrideCommonResponse,
+      response: {
+        status: 400,
+        body: { foo: 'bar' },
+      },
+    });
+
+    expect(validatedResponse).toEqual({
+      status: 400,
+      body: { foo: 'bar' },
+    });
+  });
+
+  it('fails validation on overridden zod common response', () => {
+    expect(() => {
+      validateResponse({
+        appRoute: contract.overrideCommonResponse,
+        response: {
+          status: 400,
+          body: { message: 'Bad Request' },
+        },
+      });
+    }).toThrow(TsRestResponseValidationError);
+  });
+});

package/src/lib/server.ts

@@ -0,0 +1,83 @@
+import { HTTPStatusCode } from './status-codes';
+import { TsRestResponseValidationError } from './response-validation-error';
+import {
+  AppRoute,
+  ContractAnyType,
+  ContractNoBody,
+  ContractNoBodyType,
+  ContractOtherResponse,
+} from './dsl';
+import {
+  parseAsStandardSchema,
+  validateIfSchema,
+} from './standard-schema-utils';
+import { StandardSchemaError } from './validation-error';
+
+export const isAppRouteResponse = (
+  value: unknown,
+): value is { status: HTTPStatusCode; body?: any } => {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    'status' in value &&
+    typeof value.status === 'number'
+  );
+};
+
+export const isAppRouteOtherResponse = (
+  response:
+    | ContractAnyType
+    | ContractNoBodyType
+    | ContractOtherResponse<ContractAnyType>,
+): response is ContractOtherResponse<ContractAnyType> => {
+  return (
+    response != null &&
+    typeof response === 'object' &&
+    'contentType' in response
+  );
+};
+
+export const isAppRouteNoBody = (
+  response:
+    | ContractAnyType
+    | ContractNoBodyType
+    | ContractOtherResponse<ContractAnyType>,
+): response is ContractNoBodyType => {
+  return response === ContractNoBody;
+};
+
+export const validateResponse = ({
+  appRoute,
+  response,
+}: {
+  appRoute: AppRoute;
+  response: { status: number; body?: unknown };
+}): { status: number; body?: unknown } => {
+  if (isAppRouteResponse(response)) {
+    const responseType = appRoute.responses[response.status];
+
+    const responseSchema = isAppRouteOtherResponse(responseType)
+      ? responseType.body
+      : responseType;
+
+    const responseStandardSchema = parseAsStandardSchema(responseSchema);
+    const responseValidation = validateIfSchema(
+      response.body,
+      responseStandardSchema,
+    );
+
+    if (responseValidation.error) {
+      throw new TsRestResponseValidationError(
+        appRoute,
+        responseValidation.error as StandardSchemaError,
+      );
+    }
+
+    return {
+      status: response.status,
+      body: responseValidation.value,
+    };
+  }
+
+  return response;
+};

package/src/lib/standard-schema-utils.spec.ts

@@ -0,0 +1,218 @@
+import { StandardSchemaV1 } from './standard-schema';
+import {
+  isStandardSchema,
+  parseAsStandardSchema,
+  validateAgainstStandardSchema,
+  validateMultiSchemaObject,
+  validateIfSchema,
+} from './standard-schema-utils';
+import { z } from 'zod';
+import * as v from 'valibot';
+import { StandardSchemaError } from './validation-error';
+import { initContract } from './dsl';
+
+const c = initContract();
+
+describe('standard schema utils', () => {
+  describe('validateAgainstStandardSchema', () => {
+    it('zod 3', () => {
+      const value = { foo: 'bar' };
+
+      const schema = parseAsStandardSchema(z.object({ foo: z.string() }))!;
+      const result = validateAgainstStandardSchema(value, schema);
+
+      expect(result).toEqual({ value: { foo: 'bar' } });
+    });
+
+    it('valibot', () => {
+      const value = { foo: 'bar' };
+      const schema = parseAsStandardSchema(v.object({ foo: v.string() }))!;
+      const result = validateAgainstStandardSchema(value, schema);
+
+      expect(result).toEqual({ value: { foo: 'bar' } });
+    });
+  });
+
+  describe('isStandardSchema', () => {
+    const diyStandardSchema = {
+      '~standard': {
+        version: 1,
+        vendor: 'ts-rest-test',
+        validate: () => ({ value: {} }),
+      },
+    };
+    it.each([
+      {
+        input: v.object({ foo: v.string() }),
+        expected: true,
+        description: 'valibot',
+      },
+      {
+        input: diyStandardSchema,
+        expected: true,
+        description: 'diy standard schema',
+      },
+      { input: null, expected: false, description: 'null' },
+      { input: undefined, expected: false, description: 'undefined' },
+      { input: 1, expected: false, description: '1' },
+      { input: true, expected: false, description: 'true' },
+      { input: 'foo', expected: false, description: 'foo' },
+      { input: false, expected: false, description: 'false' },
+    ])('should return $expected for $description', ({ input, expected }) => {
+      expect(isStandardSchema(input)).toBe(expected);
+    });
+  });
+
+  describe('validateIfSchema', () => {
+    it('should validate the data if a schema is provided', () => {
+      const data = { foo: 'bar' };
+      const schema = z.object({ foo: z.string() });
+
+      const result = validateIfSchema(data, schema);
+
+      expect(result).toEqual({
+        value: { foo: 'bar' },
+        schemasUsed: [schema],
+      });
+    });
+
+    it('should pass through the data if no schema is provided', () => {
+      const data = { foo: 'bar' };
+
+      const result = validateIfSchema(data, null);
+
+      expect(result).toEqual({ value: { foo: 'bar' }, schemasUsed: [] });
+    });
+  });
+
+  describe('validateMultiSchemaObject', () => {
+    it('should error for missing headers', () => {
+      const headers = {
+        'x-foo': 'bar',
+      };
+
+      const headersSchema = {
+        'x-foo': z.string(),
+        'x-bar': z.string(),
+      };
+
+      const result = validateMultiSchemaObject(headers, headersSchema);
+
+      expect(result).toStrictEqual({
+        error: new StandardSchemaError([
+          {
+            expected: 'string',
+            code: 'invalid_type',
+            path: ['x-bar'],
+            message: 'Invalid input: expected string, received undefined',
+          } as StandardSchemaV1.Issue,
+        ]),
+        schemasUsed: [headersSchema['x-foo'], headersSchema['x-bar']],
+      });
+    });
+
+    it('should not error for a missing schema', () => {
+      const headers = {
+        'x-foo': 'bar',
+      };
+
+      const result = validateMultiSchemaObject(headers, undefined);
+
+      expect(result).toEqual({
+        value: {
+          'x-foo': 'bar',
+        },
+        schemasUsed: [],
+      });
+    });
+
+    it('should work for a valibot object', () => {
+      const headers = {
+        'x-foo': 'bar',
+        'x-bar': 'baz',
+      };
+
+      const headersSchema = {
+        'x-foo': v.string(),
+        'x-bar': v.string(),
+      };
+
+      const result = validateMultiSchemaObject(headers, headersSchema);
+
+      expect(result).toEqual({
+        value: {
+          'x-foo': 'bar',
+          'x-bar': 'baz',
+        },
+        schemasUsed: [headersSchema['x-foo'], headersSchema['x-bar']],
+      });
+    });
+
+    it('should error if missing a required header', () => {
+      const schema = { 'x-foo': v.string() };
+      const result = validateMultiSchemaObject({}, schema);
+
+      expect(result).toEqual({
+        error: new StandardSchemaError([
+          {
+            kind: 'schema',
+            type: 'string',
+            expected: 'string',
+            received: 'undefined',
+            message: 'Invalid type: Expected string but received undefined',
+            path: ['x-foo'],
+          } as StandardSchemaV1.Issue,
+        ]),
+        schemasUsed: [schema['x-foo']],
+      });
+    });
+
+    it('should error if the header is the wrong type', () => {
+      const schema = v.string();
+      const result = validateMultiSchemaObject(
+        { 'x-foo': 1 },
+        { 'x-foo': schema },
+      );
+
+      expect(result).toEqual({
+        error: new StandardSchemaError([
+          {
+            kind: 'schema',
+            type: 'string',
+            input: 1,
+            expected: 'string',
+            received: '1',
+            message: 'Invalid type: Expected string but received 1',
+            path: ['x-foo'],
+          } as StandardSchemaV1.Issue,
+        ]),
+        schemasUsed: [schema],
+      });
+    });
+
+    it('should gracefully deal with null, and with other helpers like c.type()', () => {
+      const headers = {
+        'x-foo': 'bar',
+        'x-bar': 1,
+        'x-baz': 1,
+      };
+
+      const headersSchema = {
+        'x-foo': c.type<string>(),
+        'x-bar': null,
+        'x-baz': c.type<null>(),
+      };
+
+      const result = validateMultiSchemaObject(headers, headersSchema);
+
+      expect(result).toEqual({
+        value: {
+          'x-foo': 'bar',
+          'x-bar': 1,
+          'x-baz': 1,
+        },
+        schemasUsed: [],
+      });
+    });
+  });
+});