@rossum/api-client 0.1.23 → 0.1.25

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';

package/src/triggers/models/trigger.schema.ts

@@ -1,24 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-import { idSchema, urlSchema } from '../../utils/codecUtils.schema';
-
-export const triggerUrlSchema = urlSchema;
-
-export const triggerEventTypeSchema = z.union([
-  z.literal('email_with_no_processable_attachments'),
-  z.literal('annotation_created'),
-  z.literal('annotation_imported'),
-  z.literal('annotation_confirmed'),
-  z.literal('annotation_exported'),
-  z.literal('validation'),
-]);
-
-export const triggerSchema = z.object({
-  id: idSchema,
-  url: urlSchema,
-  queue: urlSchema,
-  event: triggerEventTypeSchema,
-  condition: z.record(z.unknown()).nullable(),
-  emailTemplates: z.array(urlSchema),
-  deleteRecommendations: z.array(urlSchema),
-});

package/src/triggers/models/trigger.ts

@@ -1,21 +0,0 @@
-import { ID, Url } from '../../utils/codecUtils';
-
-export type TriggerUrl = Url;
-
-export type TriggerEventType =
-  | 'email_with_no_processable_attachments'
-  | 'annotation_created'
-  | 'annotation_imported'
-  | 'annotation_confirmed'
-  | 'annotation_exported'
-  | 'validation';
-
-export type Trigger = {
-  id: ID;
-  url: Url;
-  queue: Url;
-  event: TriggerEventType;
-  condition: Record<string, unknown> | null;
-  emailTemplates: Url[];
-  deleteRecommendations: Url[];
-};

package/src/types.schema.ts

@@ -1,4 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-
-export const urlSchema = z.string();

package/src/types.ts

@@ -1 +0,0 @@
-export type Url = string;

package/src/uploads/endpoints/get.ts

@@ -1,11 +0,0 @@
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import { Upload } from '../models/upload';
-import { uploadSchema } from '../models/upload.schema';
-
-export const get = (uploadId: number) => {
-  return {
-    endpoint: `/uploads/${uploadId}`,
-    method: 'GET',
-    responseSchema: uploadSchema,
-  } as const;
-};

package/src/uploads/endpoints/index.ts

@@ -1,7 +0,0 @@
-import { get } from './get';
-import { post } from './post';
-
-export const uploads = {
-  get,
-  post,
-};

package/src/uploads/endpoints/post.schema.ts

@@ -1,11 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-import { urlSchema } from '../../utils/codecUtils.schema';
-
-export const uploadsPostQuerySchema = z.object({
-  queue: z.number(),
-});
-
-export const uploadsPostResponseSchema = z.object({
-  url: urlSchema,
-});

package/src/uploads/endpoints/post.ts

@@ -1,37 +0,0 @@
-import { z } from 'zod';
-import { Url } from '../../utils/codecUtils';
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import {
-  uploadsPostResponseSchema,
-  uploadsPostQuerySchema,
-} from './post.schema';
-
-export type UploadsPostQuery = {
-  queue: number;
-};
-
-export type UploadsPostResponse = {
-  url: Url;
-};
-
-export const post = (
-  queueId: number,
-  data: unknown,
-  name: string = '',
-  signal?: AbortSignal
-) => {
-  const encodedFilename = encodeURIComponent(name);
-  // replace strips trailing slash from the endpoint URL in case of missing filename
-  const endpoint = `/uploads/${encodedFilename}`.replace(/\/$/, '');
-  return {
-    endpoint,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    query: { queue: queueId },
-    querySchema: uploadsPostQuerySchema,
-    responseSchema: uploadsPostResponseSchema,
-    payloadSchema: z.unknown(),
-    payload: data,
-    signal,
-  } as const;
-};

package/src/uploads/index.ts

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

package/src/uploads/models/index.ts

@@ -1,2 +0,0 @@
-export * from './upload';
-export * from './upload.schema';

package/src/uploads/models/upload.schema.ts

@@ -1,16 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-import { urlSchema } from '../../utils/codecUtils.schema';
-
-export const uploadSchema = z.object({
-  id: z.number(),
-  url: urlSchema,
-  organization: urlSchema,
-  creator: urlSchema.nullable(),
-  createdAt: z.string(),
-  queue: urlSchema,
-  email: urlSchema.nullable(),
-  documents: z.array(urlSchema),
-  additionalDocuments: z.array(urlSchema),
-  annotations: z.array(urlSchema),
-});

package/src/uploads/models/upload.ts

@@ -1,14 +0,0 @@
-import { Url } from '../../utils/codecUtils';
-
-export type Upload = {
-  id: number;
-  url: Url;
-  organization: Url;
-  creator: Url | null;
-  createdAt: string;
-  queue: Url;
-  email: Url | null;
-  documents: Url[];
-  additionalDocuments: Url[];
-  annotations: Url[];
-};

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

@@ -1,16 +0,0 @@
-// Generated by ts-to-zod
-import { z } from 'zod';
-
-export const createUserPayloadSchema = z.object({
-  authType: z.string(),
-  email: z.string().optional(),
-  groups: z.array(z.string()),
-  queues: z.array(z.string()),
-  username: z.string(),
-  firstName: z.string().optional(),
-  lastName: z.string().optional(),
-  organization: z.string().optional(),
-  password: z.string().optional(),
-  url: z.string().optional(),
-  uiSettings: z.unknown().optional(),
-});

package/src/users/endpoints/create.ts

@@ -1,28 +0,0 @@
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import { User } from '../models/user';
-import { userSchema } from '../models/user.schema';
-import { createUserPayloadSchema } from './create.schema';
-
-export type CreateUserPayload = {
-  authType: string;
-  email?: string;
-  groups: string[];
-  queues: string[];
-  username: string;
-  firstName?: string;
-  lastName?: string;
-  organization?: string;
-  password?: string;
-  url?: string;
-  uiSettings?: unknown;
-};
-
-export const create = (payload: CreateUserPayload) => {
-  return {
-    endpoint: `/users`,
-    method: 'POST',
-    responseSchema: userSchema,
-    payloadSchema: createUserPayloadSchema,
-    payload,
-  } as const;
-};

package/src/users/endpoints/delete.ts

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

package/src/users/endpoints/get.ts

@@ -1,11 +0,0 @@
-import { ElisRequestConfig } from '../../utils/requestConfig';
-import { userSchema } from '../models';
-import { User } from '../models/user';
-
-export const get = (userId: string) => {
-  return {
-    endpoint: `/users/${userId}`,
-    method: 'GET',
-    responseSchema: userSchema,
-  } as const;
-};