@contember/client-content 2.0.0-alpha.6 → 2.0.0-alpha.8

package/tests/cases/unit/query.test.ts

@@ -0,0 +1,519 @@
+import { describe, expect, test } from 'vitest'
+import { createClient } from '../../lib'
+import { Input } from '@contember/schema'
+import OrderDirection = Input.OrderDirection
+import { queryBuilder } from '../../client'
+
+describe('queries', () => {
+
+	const qb = queryBuilder
+	test('list', async () => {
+		const [client, calls] = createClient({
+			authors: [
+				{
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					name: 'John',
+					email: 'bar@localhost',
+				},
+			],
+		})
+		const result = await client.query({
+			authors: qb.list('Author', {}, it => it.$$()),
+		})
+		expect(result).toEqual({
+			authors: [
+				{
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					name: 'John',
+					email: 'bar@localhost',
+				},
+			],
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query {
+				authors: listAuthor {
+					id
+					name
+					email
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot('{}')
+	})
+
+	test('multiple queries', async () => {
+		const [client, calls] = createClient({
+			authors: [
+				{
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					name: 'John',
+					email: 'bar@localhost',
+				},
+			],
+			posts: [
+				{
+					title: 'Post 1',
+					content: 'Content 1',
+				},
+				{
+					title: 'Post 2',
+					content: 'Content 2',
+				},
+			],
+		})
+		const result = await client.query({
+			authors: qb.list('Author', {}, it => it.$$()),
+			posts: qb.list('Post', {}, it => it.$$()),
+		})
+		expect(result).toEqual({
+			authors: [
+				{
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					name: 'John',
+					email: 'bar@localhost',
+				},
+			],
+			posts: [
+				{
+					title: 'Post 1',
+					content: 'Content 1',
+				},
+				{
+					title: 'Post 2',
+					content: 'Content 2',
+				},
+			],
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query {
+				authors: listAuthor {
+					id
+					name
+					email
+				}
+				posts: listPost {
+					id
+					publishedAt
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot('{}')
+	})
+
+
+	test('single query', async () => {
+		const [client, calls] = createClient({
+			value: [
+				{
+					title: 'Post 1',
+					content: 'Content 1',
+				},
+				{
+					title: 'Post 2',
+					content: 'Content 2',
+				},
+			],
+		})
+
+		const result = await client.query(qb.list('Post', {}, it => it.$$()))
+		expect(result).toEqual([
+			{
+				title: 'Post 1',
+				content: 'Content 1',
+			},
+			{
+				title: 'Post 2',
+				content: 'Content 2',
+			},
+		])
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query {
+				value: listPost {
+					id
+					publishedAt
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot('{}')
+	})
+
+
+	test('nested object', async () => {
+		const [client, calls] = createClient()
+		await client.query({
+			authors: qb.list('Author', {}, it => it.$$().$('posts', {}, it => it.$$().$('tags', {}, it => it.$$()))),
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query {
+				authors: listAuthor {
+					id
+					name
+					email
+					posts {
+						id
+						publishedAt
+						tags {
+							id
+							name
+						}
+					}
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot('{}')
+	})
+	test('nested object args', async () => {
+		const [client, calls] = createClient()
+		await client.query({
+			authors: qb.list('Author', {}, it => it.$$().$('posts', {
+				limit: 10,
+				filter: { tags: { name: { eq: 'foo' } } },
+			}, it => it.$$())),
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query($PostWhere_0: PostWhere, $Int_1: Int) {
+				authors: listAuthor {
+					id
+					name
+					email
+					posts(filter: $PostWhere_0, limit: $Int_1) {
+						id
+						publishedAt
+					}
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot(`
+			{
+			  "Int_1": 10,
+			  "PostWhere_0": {
+			    "tags": {
+			      "name": {
+			        "eq": "foo",
+			      },
+			    },
+			  },
+			}
+		`)
+	})
+
+
+	test('list with args', async () => {
+		const [client, calls] = createClient()
+		await client.query({
+			authors: qb.list('Author', {
+				filter: { name: { eq: 'John' } },
+				orderBy: [{ name: OrderDirection.asc }],
+				limit: 10,
+				offset: 20,
+			}, it => it.$$()),
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query($AuthorWhere_0: AuthorWhere, $AuthorOrderBy_1: [AuthorOrderBy!], $Int_2: Int, $Int_3: Int) {
+				authors: listAuthor(filter: $AuthorWhere_0, orderBy: $AuthorOrderBy_1, limit: $Int_2, offset: $Int_3) {
+					id
+					name
+					email
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot(`
+			{
+			  "AuthorOrderBy_1": [
+			    {
+			      "name": "asc",
+			    },
+			  ],
+			  "AuthorWhere_0": {
+			    "name": {
+			      "eq": "John",
+			    },
+			  },
+			  "Int_2": 10,
+			  "Int_3": 20,
+			}
+		`)
+	})
+
+
+	test('get by id', async () => {
+		const [client, calls] = createClient()
+		const result = await client.query({
+			authors: qb.get('Author', {
+				by: { id: 'ca7a9b84-efbb-435d-a063-da11f205335a' },
+			}, it => it.$$()),
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchInlineSnapshot(`
+			"query($AuthorUniqueWhere_0: AuthorUniqueWhere!) {
+				authors: getAuthor(by: $AuthorUniqueWhere_0) {
+					id
+					name
+					email
+				}
+			}
+			"
+		`)
+		expect(calls[0].variables).toMatchInlineSnapshot(`
+			{
+			  "AuthorUniqueWhere_0": {
+			    "id": "ca7a9b84-efbb-435d-a063-da11f205335a",
+			  },
+			}
+		`)
+	})
+
+	test('top level list transform', async () => {
+		const [client, calls] = createClient({
+			authors: [
+				{
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					name: 'Jane',
+					email: 'bar@localhost',
+				},
+			],
+		})
+		const result = await client.query({
+			authors: qb.list('Author', {}, it => it
+				.$$()
+				.transform(it => ({
+					...it,
+					label: `${it.name} (${it.email})`,
+				})),
+			),
+		})
+		expect(result).toEqual({
+			authors: [
+				{
+					name: 'John',
+					email: 'foo@localhost',
+					label: 'John (foo@localhost)',
+				},
+				{
+					name: 'Jane',
+					email: 'bar@localhost',
+					label: 'Jane (bar@localhost)',
+				},
+			],
+		})
+		expect(calls).toHaveLength(1)
+	})
+
+	test('top level get transform', async () => {
+		const [client, calls] = createClient({
+			author: {
+				name: 'John',
+				email: 'foo@localhost',
+			},
+		})
+		const result = await client.query({
+			author: qb.get('Author', { by: { id: '123' } }, it => it
+				.$$()
+				.transform(it => ({
+					...it,
+					label: `${it.name} (${it.email})`,
+				})),
+			),
+		})
+		expect(result).toEqual({
+			author: {
+				name: 'John',
+				email: 'foo@localhost',
+				label: 'John (foo@localhost)',
+			},
+		})
+		expect(calls).toHaveLength(1)
+	})
+
+
+	test('nested has-many transform', async () => {
+		const [client, calls] = createClient({
+			author: {
+				name: 'John',
+				email: 'foo@localhost',
+				posts: [
+					{
+						publishedAt: '2021-01-01T00:00:00Z',
+					},
+					{
+						publishedAt: '2021-01-02T00:00:00Z',
+					},
+				],
+			},
+		})
+		const result = await client.query({
+			author: qb.get('Author', { by: { id: '123' } }, it => it
+				.$$()
+				.$('posts', {}, it => it.$$().transform(it => ({
+					...it,
+					publishYear: it.publishedAt ? new Date(it.publishedAt).getFullYear() : null,
+				}))),
+			),
+		})
+		expect(result).toEqual({
+			author: {
+				name: 'John',
+				email: 'foo@localhost',
+				posts: [
+					{
+						publishedAt: '2021-01-01T00:00:00Z',
+						publishYear: 2021,
+					},
+					{
+						publishedAt: '2021-01-02T00:00:00Z',
+						publishYear: 2021,
+					},
+				],
+			},
+		})
+		expect(calls).toHaveLength(1)
+	})
+
+
+	test('nested has-one transform', async () => {
+		const [client, calls] = createClient({
+			post: {
+				publishedAt: '2021-01-01T00:00:00Z',
+				author: {
+					name: 'John',
+					email: 'foo@localhost',
+				},
+			},
+		})
+		const author = qb.fragment('Author', it => it
+			.$$()
+			.transform(it => ({
+				...it,
+				label: `${it.name} (${it.email})`,
+			})),
+		)
+
+		const result = await client.query({
+			post: qb.get('Post', { by: { id: '123' } }, it => it
+				.$$()
+				.$('author', author),
+			),
+		})
+		expect(result).toEqual({
+			post: {
+				publishedAt: '2021-01-01T00:00:00Z',
+				author: {
+					name: 'John',
+					email: 'foo@localhost',
+					label: 'John (foo@localhost)',
+				},
+			},
+		})
+	})
+
+
+	test('nested has-many-by transform', async () => {
+		const [client, calls] = createClient({
+			post: {
+				publishedAt: '2021-01-01T00:00:00Z',
+				localesByLocale: {
+					title: 'Hello',
+				},
+			},
+		})
+		const result = await client.query({
+			post: qb.get('Post', { by: { id: '123' } }, it => it
+				.$$()
+				.$('localesByLocale', { by: { locale: { code: 'en' } } }, it => it.$$().transform(it => ({
+					...it,
+					label: it.title?.toUpperCase(),
+				}))),
+			),
+		})
+		expect(result).toEqual({
+			post: {
+				publishedAt: '2021-01-01T00:00:00Z',
+				localesByLocale: {
+					title: 'Hello',
+					label: 'HELLO',
+				},
+			},
+		})
+	})
+
+	test('multiple transforms', async () => {
+		const [client, calls] = createClient({
+			author: {
+				name: 'John',
+				email: 'foo@localhost',
+				posts: [
+					{
+						publishedAt: '2021-01-01T00:00:00Z',
+					},
+					{
+						publishedAt: '2021-01-02T00:00:00Z',
+					},
+				],
+			},
+		})
+		const result = await client.query({
+			author: qb.get('Author', { by: { id: '123' } }, it => it
+				.$$()
+				.transform(it => ({
+					...it,
+					value1: 'foo',
+				}))
+				.$('posts', {}, it => it.$$().transform(it => ({
+					...it,
+					postLabel: 'foo bar',
+				})))
+				.transform(it => ({
+					...it,
+					value2: 'bar',
+				})),
+			),
+		})
+		expect(result).toEqual({
+			author: {
+				name: 'John',
+				email: 'foo@localhost',
+				value1: 'foo',
+				value2: 'bar',
+				posts: [
+					{
+						publishedAt: '2021-01-01T00:00:00Z',
+						postLabel: 'foo bar',
+					},
+					{
+						publishedAt: '2021-01-02T00:00:00Z',
+						postLabel: 'foo bar',
+					},
+				],
+			},
+		})
+		expect(calls).toHaveLength(1)
+	})
+
+})

package/tests/cases/unit/types.test.ts

@@ -0,0 +1,144 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { assertType, describe, expect, expectTypeOf, test } from 'vitest'
+import { ContentClientInput } from '../../../src'
+import { ContemberClientEntities, FragmentOf, FragmentType, queryBuilder } from '../../client'
+
+const qb = queryBuilder
+describe('ts types', () => {
+	test('fragment - valid', async () => {
+		expectTypeOf(
+			qb.fragment('Post')
+				.$('author', qb.fragment('Author')),
+		).toMatchTypeOf<FragmentOf<'Post'>>()
+	})
+
+	test('fragment - invalid', async () => {
+		const postFragment = qb.fragment('Post')
+
+		// @ts-expect-error
+		assertType(postFragment.$('author', qb.fragment('Post')))
+	})
+
+	test('where - valid', async () => {
+		qb.list('Post', {
+			filter: {
+				publishedAt: { eq: 'foo' },
+			},
+		}, it => it.$$())
+	})
+
+	test('where - invalid with literal', async () => {
+		qb.list('Post', {
+			filter: {
+				// @ts-expect-error
+				caption: { eq: 'foo' },
+			},
+		}, it => it.$$())
+	})
+
+	test('where - invalid assignment to type', async () => {
+		const where: ContentClientInput.Where<ContemberClientEntities['Post']> = {
+			// @ts-expect-error
+			caption: { eq: 'foo' },
+		}
+	})
+
+	test('where - valid extracted without a type', async () => {
+		const where = {
+			publishedAt: { eq: 'foo' },
+		}
+		qb.list('Post', {
+			filter: where,
+		}, it => it.$$())
+	})
+
+	test('where - valid extracted with a type', async () => {
+		const where: ContentClientInput.Where<ContemberClientEntities['Post']> = {
+			publishedAt: { eq: 'foo' },
+		}
+		qb.list('Post', {
+			filter: where,
+		}, it => it.$$())
+	})
+
+	test('where - incompatible types', async () => {
+		const where: ContentClientInput.Where<ContemberClientEntities['Post']> = {
+			publishedAt: { eq: 'foo' },
+		}
+		qb.list('Author', {
+			// @ts-expect-error
+			filter: where,
+		}, it => it.$$())
+	})
+
+	test('has one field on fragment type', async () => {
+		const fragment = qb.fragment('Post', it => it.$('author', it => it.$$().$('posts', it => it.$('id'))))
+		type fragmentType = FragmentType<typeof fragment>
+		expectTypeOf<fragmentType>().toEqualTypeOf<{ author: ({ id: string; name: string | null; email: string | null } & { posts: { id: string }[] }) | null }>()
+	})
+
+
+	test('has one without arg', async () => {
+		qb.list('Post', {}, it => it.$('author', it => it.$$()))
+	})
+
+	test('has one with arg', async () => {
+		qb.list('Post', {}, it => it.$('author', { filter: { name: { eq: 'John' } } }, it => it.$$()))
+	})
+
+	test('has one with invalid arg', async () => {
+		qb.list('Post', {}, it => it
+			.$('author',
+				// @ts-expect-error
+				{ filter: { foo: { eq: 'xx' } } },
+				it => it.$$(),
+			),
+		)
+	})
+
+	test('has many without arg', async () => {
+		qb.list('Post', {}, it => it.$('locales', it => it.$$()))
+	})
+
+	test('has many with arg', async () => {
+		qb.list('Post', {}, it => it.$('locales', { filter: { locale: { code: { eq: 'cs' } } } },  it => it.$$()))
+	})
+
+	test('has many with invalid arg', async () => {
+		qb.list('Post', {}, it => it
+			.$('locales',
+				// @ts-expect-error
+				{ filter: { locale: { eq: 'cs' } } },
+				it => it.$$(),
+			),
+		)
+	})
+
+	test('reduced has may', async () => {
+		qb.list('Post', {}, it => it.$('localesByLocale', { by: { locale: { code: 'cs' } } },  it => it.$$()))
+	})
+
+	test('reduced has may - invalid "by"', async () => {
+		qb.list('Post',
+			{},
+			it => it
+				.$('localesByLocale',
+					// @ts-expect-error
+					{ by: { locale: {} } },
+					qb.fragment('PostLocale'),
+				),
+		)
+	})
+
+
+	test('invalid field', async () => {
+		expect(() => {
+			qb.list(
+				'Post',
+				{},
+				// @ts-expect-error
+				it => it.$('lorem', it => it.$$()),
+			)
+		}).toThrow('Field Post.lorem does not exist.')
+	})
+})