@rossum/api-client 0.1.24 → 0.1.25

package/src/tests/requestConfig.test.ts

@@ -1,207 +0,0 @@
-import * as E from 'fp-ts/lib/Either';
-import { describe, expect, it } from 'vitest';
-import {
-  asAxiosConfig,
-  withAuthorizationHeader,
-  withContentTypeHeaders,
-  withData,
-  withParams,
-  withRequestConfigDefaults,
-  withResponseHeaders,
-} from '../utils/requestConfig';
-import { encodeObjectToQuery } from '../utils/urlUtils';
-import {
-  AUTH_TOKEN,
-  axiosConfig,
-  BASE_URL,
-  clientConfig,
-  requestConfig,
-  TestPayloadSchema,
-  validDecodable,
-} from './helpers';
-
-describe('withRequestConfigDefaults', () => {
-  it('fills in the default fields', () => {
-    expect(withRequestConfigDefaults(requestConfig)).toEqual({
-      ...requestConfig,
-      endpoint: '/test',
-      method: 'GET',
-      responseType: 'json',
-      authorize: true,
-    });
-  });
-  it('does not override provided fields', () => {
-    expect(
-      withRequestConfigDefaults<unknown, never, never>({
-        ...requestConfig,
-        authorize: false,
-        withRossumRequestOrigin: false,
-      })
-    ).toEqual({
-      ...requestConfig,
-      endpoint: '/test',
-      method: 'GET',
-      responseType: 'json',
-      authorize: false,
-      withRossumRequestOrigin: false,
-    });
-  });
-});
-
-describe('asAxiosConfig', () => {
-  it('picks up correct fields from requestConfig into axiosConfig', () => {
-    expect(
-      asAxiosConfig<unknown, never, never>(clientConfig)({
-        ...requestConfig,
-        method: 'GET',
-      })
-    ).toEqual(
-      E.right({
-        baseURL: BASE_URL,
-        url: `/test`,
-        method: 'GET',
-        responseType: 'json',
-      })
-    );
-  });
-});
-
-describe('withResponseHeaders', () => {
-  it("adds Accept header for responseType 'json'", () => {
-    expect(
-      withResponseHeaders(clientConfig, requestConfig)(axiosConfig)
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        headers: {
-          Accept: 'application/json',
-        },
-      })
-    );
-  });
-  it('does not add JSON headers for other valid reponse types', () => {
-    expect(
-      withResponseHeaders(
-        clientConfig,
-        requestConfig
-      )({ ...axiosConfig, responseType: 'blob' })
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        responseType: 'blob',
-      })
-    );
-    expect(
-      withResponseHeaders(
-        clientConfig,
-        requestConfig
-      )({ ...axiosConfig, responseType: 'document' })
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        responseType: 'document',
-      })
-    );
-  });
-});
-
-describe('withContentTypeHeaders', () => {
-  it('adds Content-Type header if payload is specified', () => {
-    expect(
-      withContentTypeHeaders<unknown, never, any>(clientConfig, {
-        ...requestConfig,
-        contentType: 'application/json',
-        payload: {},
-        payloadSchema: TestPayloadSchema,
-      })(axiosConfig)
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      })
-    );
-  });
-  it("Adds 'application/json' if no type specified but payload present", () => {
-    expect(
-      withContentTypeHeaders<unknown, never, any>(clientConfig, {
-        ...requestConfig,
-        payload: {},
-        payloadSchema: TestPayloadSchema,
-      })(axiosConfig)
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      })
-    );
-  });
-  it('does not add the header if contentType is not specified', () => {
-    expect(
-      withContentTypeHeaders<unknown, never, never>(clientConfig, {
-        ...requestConfig,
-      })(axiosConfig)
-    ).toEqual(E.right(axiosConfig));
-  });
-});
-
-describe('withAuthorizationHeader', () => {
-  it('adds proper auth token if getAuthToken is provided', () => {
-    expect(
-      withAuthorizationHeader(clientConfig, requestConfig)(axiosConfig)
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        headers: { Authorization: `Token ${AUTH_TOKEN}` },
-      })
-    );
-  });
-});
-
-describe('withParams', () => {
-  it('does not do anything if no query is present on request', () => {
-    expect(withParams(clientConfig, requestConfig)(axiosConfig)).toEqual(
-      E.right(axiosConfig)
-    );
-  });
-  it('succeeds with decoded response otherwise', () => {
-    expect(
-      withParams<unknown, any, never>(clientConfig, {
-        ...requestConfig,
-        query: validDecodable,
-        querySchema: TestPayloadSchema,
-      })(axiosConfig)
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        params: validDecodable,
-        paramsSerializer: encodeObjectToQuery,
-      })
-    );
-  });
-});
-
-describe('withData', () => {
-  it('does not do anything if no payload is present on request', () => {
-    expect(withData(clientConfig, requestConfig)(axiosConfig)).toEqual(
-      E.right(axiosConfig)
-    );
-  });
-  it('succeeds with decoded response otherwise', () => {
-    expect(
-      withData<unknown, never, any>(clientConfig, {
-        ...requestConfig,
-        payload: validDecodable,
-        payloadSchema: TestPayloadSchema,
-      })(axiosConfig)
-    ).toEqual(
-      E.right({
-        ...axiosConfig,
-        data: validDecodable,
-      })
-    );
-  });
-});

package/src/tests/requestResponse.test.ts

@@ -1,39 +0,0 @@
-import * as E from 'fp-ts/lib/Either';
-import { describe, expect, it } from 'vitest';
-import { asDecoded } from '../utils/requestResponse';
-import {
-  clientConfig,
-  invalidDecodable,
-  requestConfig,
-  TestSchema,
-  validDecodable,
-} from './helpers';
-
-describe('asDecoded', () => {
-  it('simply returns when responseType is not json', () => {
-    expect(
-      asDecoded<any, never, never>(clientConfig, {
-        endpoint: '/test/',
-        responseType: 'blob',
-      })(validDecodable)
-    ).toEqual(E.right(validDecodable));
-  });
-  it('fails if response decoder is provided but decoding fails', () => {
-    expect(
-      asDecoded<any, never, never>(clientConfig, {
-        ...requestConfig,
-        responseType: 'json',
-        responseSchema: TestSchema,
-      })(invalidDecodable)._tag
-    ).toEqual(E.left({})._tag);
-  });
-  it('succeeds with decoded response otherwise', () => {
-    expect(
-      asDecoded<any, never, never>(clientConfig, {
-        ...requestConfig,
-        responseType: 'json',
-        responseSchema: TestSchema,
-      })(validDecodable)
-    ).toEqual(E.right(validDecodable));
-  });
-});

package/src/tests/urlUtils.test.ts

@@ -1,36 +0,0 @@
-// import { constructQuery as encodeObjectToQuery } from '../../lib/url';
-import { describe, expect, it } from 'vitest';
-import { encodeObjectToQuery } from '../utils/urlUtils';
-// TODO: Cover more complex cases:
-//  - what to do with nulls?
-//  - nested objects and arrays?
-describe('encodeObjectToQuery', () => {
-  it('should return empty string for nullish values and empty objects', () => {
-    expect(encodeObjectToQuery({})).toEqual('');
-    expect(encodeObjectToQuery(null)).toEqual('');
-    expect(encodeObjectToQuery(undefined)).toEqual('');
-  });
-  it('should encode an object with primitive values', () => {
-    expect(
-      encodeObjectToQuery({
-        str: 'a',
-        num: 7,
-        bool: true,
-      })
-    ).toEqual('str=a&num=7&bool=true');
-  });
-  it('should ignore nullish and fields', () => {
-    expect(
-      encodeObjectToQuery({
-        prop: 'a',
-        none: undefined,
-        nil: null,
-      })
-    ).toEqual('prop=a');
-  });
-  it('should encode arrays as comma-separated lists', () => {
-    expect(
-      encodeObjectToQuery({ arr: [1, 'a', true, null, undefined] })
-    ).toEqual('arr=1,a,true');
-  });
-});

package/src/tests/zod.test.ts

@@ -1,277 +0,0 @@
-import * as Either from 'fp-ts/lib/Either';
-import { describe, expect, test } from 'vitest';
-import { z } from 'zod';
-import { endpoints } from '../..';
-import {
-  asPayloadEncoder,
-  asQueryEncoder,
-  asRequestSchema,
-  asResponseDecoder,
-  asResponseSchema,
-} from '../utils';
-import { ElisRequestConfig } from '../utils/requestConfig';
-import { constructDescriptorPath, unwrapEndpoints } from './helpers';
-
-type TestCase = {
-  name: string;
-  schema: z.ZodSchema;
-  frontendBackendData: [string, any, any][];
-};
-const testCases: TestCase[] = [
-  {
-    name: 'simple object schema',
-    schema: z.object({
-      propName: z.number(),
-      propString: z.string(),
-    }),
-    frontendBackendData: [
-      [
-        'simple properties',
-        { propName: 42, propString: 'abc' },
-        { prop_name: 42, prop_string: 'abc' },
-      ],
-    ],
-  },
-  {
-    name: 'array',
-    schema: z.array(z.string()),
-    frontendBackendData: [
-      ['empty array', [], []],
-      ['non empty array', ['abc'], ['abc']],
-    ],
-  },
-  {
-    name: 'nullable object properties',
-    schema: z.object({
-      nullableProp: z.string().nullable(),
-    }),
-    frontendBackendData: [
-      ['non-null value', { nullableProp: 'abc' }, { nullable_prop: 'abc' }],
-      ['null value', { nullableProp: null }, { nullable_prop: null }],
-    ],
-  },
-  {
-    name: 'optional object properties',
-    schema: z.object({
-      optionalProp: z.string().optional(),
-    }),
-    frontendBackendData: [
-      ['value', { optionalProp: 'abc' }, { optional_prop: 'abc' }],
-      ['undefined', { optionalProp: undefined }, { optional_prop: undefined }],
-      ['missing prop', {}, {}],
-    ],
-  },
-  {
-    name: 'keep unknown properties',
-    schema: z
-      .object({
-        knownProp: z.string(),
-      })
-      // TODO how to recursively apply this? Some comment attribute, or a generic type with special support?
-      // I'd say we shouldn't even convert case of uknown properties, otherwise we can make a mistake (it's not guaranteed for all cases)
-      .passthrough(),
-    frontendBackendData: [
-      [
-        'unknown prop',
-        { knownProp: 'a', unknownProp: 'b' },
-        { known_prop: 'a', unknown_prop: 'b' },
-      ],
-    ],
-  },
-  {
-    name: 'union',
-    schema: z.object({
-      unionProp: z.union([z.literal('a'), z.literal('b'), z.literal('c')]),
-    }),
-    frontendBackendData: [
-      ['valid value', { unionProp: 'a' }, { union_prop: 'a' }],
-    ],
-  },
-  {
-    name: 'complex schema',
-    schema: z.object({
-      unionProp: z.union([z.literal('a'), z.literal('b'), z.literal('c')]),
-      nestedObj: z.object({
-        propA: z.string(),
-        propB: z.string().nullable(),
-        propC: z.string().optional(),
-        propD: z.tuple([z.number(), z.string()]),
-        propE: z.record(z.string()),
-      }),
-      array: z.array(z.object({ propArray: z.array(z.number()) })).nullable(),
-    }),
-    frontendBackendData: [
-      [
-        'value',
-        {
-          unionProp: 'a',
-          nestedObj: {
-            propA: 'something',
-            propB: null,
-            propD: [1, 'abc'],
-            propE: { someProp: 'abc' },
-          },
-          array: [{ propArray: [1, 2, 3] }],
-        },
-        {
-          union_prop: 'a',
-          nested_obj: {
-            prop_a: 'something',
-            prop_b: null,
-            prop_d: [1, 'abc'],
-            prop_e: { someProp: 'abc' },
-          },
-          array: [{ prop_array: [1, 2, 3] }],
-        },
-      ],
-    ],
-  },
-  {
-    name: 'record',
-    schema: z.record(z.number()),
-    frontendBackendData: [
-      ['empty', {}, {}],
-      ['multiple values', { aProp: 1, b_prop: 2 }, { aProp: 1, b_prop: 2 }],
-    ],
-  },
-  {
-    name: 'tuple',
-    schema: z.tuple([z.number(), z.string()]),
-    frontendBackendData: [['value', [1, 'abc'], [1, 'abc']]],
-  },
-  {
-    name: 'intersection',
-    schema: z.intersection(
-      z.object({ aProp: z.number() }),
-      z.object({ bProp: z.string() })
-    ),
-    frontendBackendData: [
-      ['value', { aProp: 1, bProp: 'abc' }, { a_prop: 1, b_prop: 'abc' }],
-    ],
-  },
-  /*
-    Background:
-    - By default ts-to-zod generates "aSchema.and(bSchema)" for intersection types A & B.
-    - The behavior of 'and' (ZodIntersection) is that it first parses the input with first schema, then with second, and merges the result.
-    - By default we have passthrough policy, so object schemas will keep unknown keys.
-    - We use automatic case conversion for known keys
-
-    If BE sends `{ x: { nested_prop: 2 } }` then it's processed as follows:
-    - first object schema will convert "x" and "nested_props" to camel case, since they are known keys
-    - second object schema doesn't know any keys, so it will just pass them through (without any conversion)
-    - when the result is merged, we get:
-
-      { x: { nestedProp: 2, nested_prop: 2 } }
-
-      which is clearly not what we want.
-
-    The current fix is, that we replace "and" (which creates ZodIntersection) with "merge", which combines two objects into one.
-    This test verifies that the fix works.
-  */
-  {
-    name: 'intersection-bug',
-    schema: z.intersection(
-      z.object({
-        x: z.object({ nestedProp: z.number() }),
-      }),
-      z.object({})
-    ),
-    frontendBackendData: [
-      ['value', { x: { nestedProp: 2 } }, { x: { nested_prop: 2 } }],
-    ],
-  },
-];
-
-// Verify that all schemas for all endpoints can be properly transformed
-describe('Endpoints', () => {
-  const unwrappedEndpoints = unwrapEndpoints(endpoints);
-
-  unwrappedEndpoints.forEach(endpointDescriptorWithPath => {
-    const endpoint = endpointDescriptorWithPath.pop();
-
-    const path = constructDescriptorPath(
-      endpointDescriptorWithPath as string[]
-    );
-
-    if (typeof endpoint !== 'function') {
-      throw new Error(
-        '`endpoint` is not a function - probably an error with unwrapping `endpoints` object or a mistake in structure/naming of endpoints!'
-      );
-    }
-
-    const e = endpoint() as ElisRequestConfig<unknown, unknown, unknown>;
-
-    test(`${path} - payload`, () => {
-      if (e.payloadSchema) {
-        asRequestSchema(e.payloadSchema);
-      }
-    });
-
-    test(`${path} - query`, () => {
-      if (e.querySchema) {
-        asRequestSchema(e.querySchema);
-      }
-    });
-
-    test(`${path} - response`, () => {
-      if (e.responseSchema) {
-        asRequestSchema(e.responseSchema);
-      }
-    });
-  });
-});
-
-testCases.forEach(tc => {
-  describe(tc.name, () => {
-    tc.frontendBackendData.forEach(([name, frontendData, backendData]) => {
-      test(`${name}: frontend -> backend`, () => {
-        const requestSchema = asRequestSchema(tc.schema);
-
-        expect(requestSchema.parse(frontendData)).toEqual(backendData);
-
-        expect(asPayloadEncoder(tc.schema).encode(frontendData)).toEqual(
-          backendData
-        );
-
-        expect(asQueryEncoder(tc.schema).encode(frontendData)).toEqual(
-          backendData
-        );
-      });
-
-      test(`${name}: backend  <- frontend`, () => {
-        const responseSchema = asResponseSchema(tc.schema);
-
-        expect(responseSchema.parse(backendData)).toEqual(frontendData);
-
-        expect(asResponseDecoder(tc.schema).decode(backendData)).toEqual(
-          Either.right(frontendData)
-        );
-      });
-    });
-  });
-});
-
-describe('Error handling', () => {
-  test('Parsing error is converted into decoding error', () => {
-    const schema = asResponseSchema(z.string());
-    const decodedSchema = asResponseDecoder(schema).decode(1213456 as unknown);
-
-    expect(
-      // No idea how does one write this properly.
-      Either.isLeft(decodedSchema) &&
-        decodedSchema.left._tag === 'Of' &&
-        decodedSchema.left.value._tag === 'Leaf' &&
-        decodedSchema.left.value.error
-    ).toEqual(
-      new z.ZodError([
-        {
-          code: 'invalid_type',
-          expected: 'string',
-          received: 'number',
-          path: [],
-          message: 'Expected string, received number',
-        },
-      ]).toString()
-    );
-  });
-});

package/src/triggers/endpoints/create.schema.ts

@@ -1,12 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-import { urlSchema } from '../../utils/codecUtils.schema';
-import { triggerEventTypeSchema } from '../models/trigger.schema';
-
-export const createTriggerPayloadSchema = z.object({
-  queue: urlSchema,
-  event: triggerEventTypeSchema,
-  condition: z.unknown().optional(),
-  emailTemplates: z.array(urlSchema).optional(),
-  deleteRecommendations: z.array(urlSchema).optional(),
-});

package/src/triggers/endpoints/create.ts

@@ -1,24 +0,0 @@
-import { Url } from '../../utils/codecUtils';
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import { Trigger, TriggerEventType } from '../models/trigger';
-import { triggerSchema } from '../models/trigger.schema';
-import { createTriggerPayloadSchema } from './create.schema';
-
-export type CreateTriggerPayload = {
-  queue: Url;
-  event: TriggerEventType;
-  // TODO what to use here?
-  condition?: unknown;
-  emailTemplates?: Url[];
-  deleteRecommendations?: Url[];
-};
-
-export const create = (payload: CreateTriggerPayload) => {
-  return {
-    endpoint: `/triggers`,
-    method: 'POST',
-    responseSchema: triggerSchema,
-    payloadSchema: createTriggerPayloadSchema,
-    payload,
-  } as const;
-};

package/src/triggers/endpoints/delete.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-import { ID } from '../../utils/codecUtils';
-import { ElisRequestConfig } from '../../utils/requestConfig';
-
-export const deleteEndpoint = (triggerId: ID) => {
-  return {
-    endpoint: `/triggers/${triggerId}`,
-    method: 'DELETE',
-    responseSchema: z.unknown(),
-  } as const;
-};

package/src/triggers/endpoints/get.ts

@@ -1,12 +0,0 @@
-import { Url } from '../../types';
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import { Trigger } from '../models/trigger';
-import { triggerSchema } from '../models/trigger.schema';
-
-export const get = (triggerUrl: Url) => {
-  return {
-    endpoint: triggerUrl,
-    method: 'GET',
-    responseSchema: triggerSchema,
-  } as const;
-};

package/src/triggers/endpoints/index.ts

@@ -1,13 +0,0 @@
-import { create } from './create';
-import { deleteEndpoint } from './delete';
-import { get } from './get';
-import { patch } from './patch';
-export { type CreateTriggerPayload } from './create';
-export { type PatchTriggerPayload } from './patch';
-
-export const triggers = {
-  create,
-  get,
-  patch,
-  delete: deleteEndpoint,
-};

package/src/triggers/endpoints/patch.schema.ts

@@ -1,14 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-import { urlSchema } from '../../utils/codecUtils.schema';
-import { triggerEventTypeSchema } from '../models/trigger.schema';
-
-export const patchTriggerPayloadSchema = z
-  .object({
-    queue: urlSchema,
-    event: triggerEventTypeSchema,
-    condition: z.unknown(),
-    emailTemplates: z.array(urlSchema),
-    deleteRecommendations: z.array(urlSchema),
-  })
-  .partial();

package/src/triggers/endpoints/patch.ts

@@ -1,24 +0,0 @@
-import { ID, Url } from '../../utils/codecUtils';
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import { Trigger, TriggerEventType } from '../models/trigger';
-import { triggerSchema } from '../models/trigger.schema';
-import { patchTriggerPayloadSchema } from './patch.schema';
-
-export type PatchTriggerPayload = Partial<{
-  queue: Url;
-  event: TriggerEventType;
-  // TODO what to use here?
-  condition: unknown;
-  emailTemplates: Url[];
-  deleteRecommendations: Url[];
-}>;
-
-export const patch = (triggerId: ID, payload: PatchTriggerPayload) => {
-  return {
-    endpoint: `/triggers/${triggerId}`,
-    method: 'PATCH',
-    responseSchema: triggerSchema,
-    payloadSchema: patchTriggerPayloadSchema,
-    payload,
-  } as const;
-};

package/src/triggers/index.ts

@@ -1,3 +0,0 @@
-export * from './models';
-export * from './endpoints';
-

package/src/triggers/models/index.ts

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