@contember/client-content 2.0.0-alpha.4 → 2.0.0-alpha.40

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

@@ -0,0 +1,450 @@
+import { describe, expect, test } from 'bun:test'
+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: [
+				{
+					id: '1',
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					id: '2',
+					name: 'John',
+					email: 'bar@localhost',
+				},
+			],
+		})
+		const result = await client.query({
+			authors: qb.list('Author', {}, it => it.$$()),
+		})
+		expect(result).toStrictEqual({
+			authors: [
+				{
+					id: '1',
+					name: 'John',
+					email: 'foo@localhost',
+				},
+				{
+					id: '2',
+					name: 'John',
+					email: 'bar@localhost',
+				},
+			],
+		})
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchSnapshot()
+		expect(calls[0].variables).toStrictEqual({})
+	})
+
+	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 as any).toStrictEqual({
+			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).toMatchSnapshot()
+		expect(calls[0].variables).toEqual({})
+	})
+
+
+	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 as any).toStrictEqual([
+			{
+				title: 'Post 1',
+				content: 'Content 1',
+			},
+			{
+				title: 'Post 2',
+				content: 'Content 2',
+			},
+		])
+		expect(calls).toHaveLength(1)
+		expect(calls[0].query).toMatchSnapshot()
+		expect(calls[0].variables).toEqual({})
+	})
+
+
+	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).toMatchSnapshot()
+		expect(calls[0].variables).toEqual({})
+	})
+	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).toMatchSnapshot()
+		expect(calls[0].variables).toStrictEqual({
+			'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).toMatchSnapshot(`
+			"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).toStrictEqual(
+			{
+				'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).toMatchSnapshot()
+		expect(calls[0].variables).toEqual({
+			'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 as any).toStrictEqual({
+			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 as any).toStrictEqual({
+			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 as any).toStrictEqual({
+			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 as any).toStrictEqual({
+			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 as any).toStrictEqual({
+			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 as any).toStrictEqual({
+			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,145 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { describe, expect, test } from 'bun:test'
+import { ContentClientInput } from '../../../src'
+import { ContemberClientEntities, FragmentOf, FragmentType, queryBuilder } from '../../client'
+import { expectTypeOf } from 'expect-type'
+
+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
+		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.')
+	})
+})

package/tests/client/entities.ts

@@ -0,0 +1,108 @@
+
+export type JSONPrimitive = string | number | boolean | null
+export type JSONValue = JSONPrimitive | JSONObject | JSONArray
+export type JSONObject = { readonly [K in string]?: JSONValue }
+export type JSONArray = readonly JSONValue[]
+
+export type Locale <OverRelation extends string | never = never> = {
+	name: 'Locale'
+	unique:
+		| Omit<{ id: string}, OverRelation>
+		| Omit<{ code: string}, OverRelation>
+	columns: {
+		id: string
+		code: string
+	}
+	hasOne: {
+	}
+	hasMany: {
+	}
+	hasManyBy: {
+	}
+}
+export type Author <OverRelation extends string | never = never> = {
+	name: 'Author'
+	unique:
+		| Omit<{ id: string}, OverRelation>
+		| Omit<{ posts: Post['unique']}, OverRelation>
+	columns: {
+		id: string
+		name: string | null
+		email: string | null
+	}
+	hasOne: {
+	}
+	hasMany: {
+		posts: Post<'author'>
+	}
+	hasManyBy: {
+		postsByLocales: { entity: Post; by: {locales: PostLocale['unique']}  }
+	}
+}
+export type Post <OverRelation extends string | never = never> = {
+	name: 'Post'
+	unique:
+		| Omit<{ id: string}, OverRelation>
+		| Omit<{ locales: PostLocale['unique']}, OverRelation>
+	columns: {
+		id: string
+		publishedAt: string | null
+	}
+	hasOne: {
+		author: Author
+	}
+	hasMany: {
+		tags: Tag
+		locales: PostLocale<'post'>
+	}
+	hasManyBy: {
+		localesByLocale: { entity: PostLocale; by: {locale: Locale['unique']}  }
+	}
+}
+export type PostLocale <OverRelation extends string | never = never> = {
+	name: 'PostLocale'
+	unique:
+		| Omit<{ id: string}, OverRelation>
+		| Omit<{ locale: Locale['unique'], post: Post['unique']}, OverRelation>
+	columns: {
+		id: string
+		title: string | null
+		content: string | null
+	}
+	hasOne: {
+		locale: Locale
+		post: Post
+	}
+	hasMany: {
+	}
+	hasManyBy: {
+	}
+}
+export type Tag <OverRelation extends string | never = never> = {
+	name: 'Tag'
+	unique:
+		| Omit<{ id: string}, OverRelation>
+	columns: {
+		id: string
+		name: string | null
+	}
+	hasOne: {
+	}
+	hasMany: {
+		posts: Post
+	}
+	hasManyBy: {
+	}
+}
+
+export type ContemberClientEntities = {
+	Locale: Locale
+	Author: Author
+	Post: Post
+	PostLocale: PostLocale
+	Tag: Tag
+}
+
+export type ContemberClientSchema = {
+	entities: ContemberClientEntities
+}

package/tests/client/enums.ts

@@ -0,0 +1,3 @@
+export type ContemberClientEnums = {
+}
+

package/tests/client/index.ts

@@ -0,0 +1,17 @@
+
+import { ContemberClientNames } from './names'
+import type { ContemberClientSchema } from './entities'
+import { ContentQueryBuilder, TypedContentQueryBuilder, TypedEntitySelection } from '@contember/client-content'
+export * from './names'
+export * from './enums'
+export * from './entities'
+
+export const queryBuilder = new ContentQueryBuilder(ContemberClientNames) as unknown as TypedContentQueryBuilder<ContemberClientSchema>
+
+export type FragmentOf<EntityName extends keyof ContemberClientSchema['entities'] & string, Data = unknown> =
+TypedEntitySelection<ContemberClientSchema, EntityName, ContemberClientSchema['entities'][EntityName], Data>
+
+export type FragmentType<T extends TypedEntitySelection<any, any, any, any> = any> =
+T extends TypedEntitySelection<any, any, any, infer TFields>
+	? TFields
+	: never