@contember/binding-common 2.0.0-alpha.17

package/src/utils/createQueryBuilder.ts

@@ -0,0 +1,31 @@
+import { ContentQueryBuilder, SchemaEntityNames, SchemaNames } from '@contember/client-content'
+import { Schema, SchemaRelation } from '../schema'
+
+export const createQueryBuilder = (schema: Schema) => {
+	const schemaNames: SchemaNames = {
+		entities: Object.fromEntries(schema.getEntityNames().map((it): [string, SchemaEntityNames<string>] => {
+			const entity = schema.getEntity(it)
+			return [it, {
+				name: it,
+				scalars: Array.from(entity.fields.values()).filter(it => it.__typename === '_Column').map(it => it.name),
+				fields: Object.fromEntries(Array.from(entity.fields.values()).map(it => {
+					if (it.__typename === '_Column') {
+						return [it.name, { type: 'column' }]
+					}
+					if (it.__typename === '_Relation') {
+						return [
+							it.name,
+							{
+								type: it.type === 'ManyHasMany' || it.type === 'OneHasMany' ? 'many' : 'one',
+								entity: (it as SchemaRelation).targetEntity,
+							},
+						]
+					}
+					throw new Error()
+				})),
+			}]
+		})),
+	}
+
+	return new ContentQueryBuilder(schemaNames)
+}

package/src/utils/generateEnumerabilityPreventingEntropy.ts

@@ -0,0 +1,3 @@
+export const generateEnumerabilityPreventingEntropy = (length: number = 5): string => {
+	return (Math.random() * Math.pow(10, length)).toFixed(0).padStart(length, '0')
+}

package/tests/cases/unit/queryLanguage/filter.spec.tsx

@@ -0,0 +1,100 @@
+import { expect, it, describe } from 'vitest'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+
+const parse = (input: string, environment: Environment = Environment.create()) => {
+	return Parser.parseQueryLanguageExpression(input, 'filter', environment)
+}
+
+describe('filter QueryLanguage parser', () => {
+	it('should parse simple filters', () => {
+		expect(parse('[foo > 123]')).toEqual({ foo: { gt: 123 } })
+		expect(parse('[foo = 456]')).toEqual({ foo: { eq: 456 } })
+		expect(parse('[foo != 456]')).toEqual({ foo: { notEq: 456 } })
+		expect(parse('[foo <= 789]')).toEqual({ foo: { lte: 789 } })
+	})
+
+	it('should parse variable filters', () => {
+		const myEnv = Environment.create().withVariables({
+			myFilter: { foo: { eq: 123 } },
+		})
+		expect(parse('[$myFilter]', myEnv)).toEqual({ foo: { eq: 123 } })
+		expect(parse('[!$myFilter]', myEnv)).toEqual({ not: { foo: { eq: 123 } } })
+	})
+
+	it('should parse filter sub expressions', () => {
+		const myEnv = Environment.create().withVariables({
+			myFilter: { foo: { eq: 123 } },
+		})
+		expect(parse('[!($myFilter || x < 456)]', myEnv)).toEqual({
+			not: {
+				or: [{ foo: { eq: 123 } }, { x: { lt: 456 } }],
+			},
+		})
+	})
+
+	it('should parse complex filter conditions', () => {
+		expect(parse('[a < 1 || b = 2 && c != 3 || d > 4]')).toEqual({
+			or: [
+				{ a: { lt: 1 } },
+				{
+					and: [{ b: { eq: 2 } }, { c: { notEq: 3 } }],
+				},
+				{
+					d: { gt: 4 },
+				},
+			],
+		})
+	})
+
+	it('should parse conditions with nested fields', () => {
+		expect(parse('[a.b.c < 123 && a.d = 456]')).toEqual({
+			and: [{ a: { b: { c: { lt: 123 } } } }, { a: { d: { eq: 456 } } }],
+		})
+	})
+
+	it('should parse conditions with sub-filters', () => {
+		expect(parse(`[tags[name = 'foo' && isPublished = true]]`)).toEqual({
+			tags: {
+				and: [
+					{ name: { eq: 'foo' } },
+					{ isPublished: { eq: true } },
+				],
+			},
+		})
+	})
+
+	it('should parse conditions with quantifiers', () => {
+		expect(parse(`[tags:none[name = 'foo' && isPublished = true]]`)).toEqual({
+			not: {
+				tags: {
+					and: [
+						{ name: { eq: 'foo' } },
+						{ isPublished: { eq: true } },
+					],
+				},
+			},
+		})
+	})
+
+
+	it('should parse conditions with quantifiers', () => {
+		expect(parse(`[tags:all[isPublished = true]]`)).toEqual({
+			not: {
+				tags: {
+					not: { isPublished: { eq: true } },
+				},
+			},
+		})
+	})
+
+	it('should parse conditions with quantifiers without subfilter', () => {
+		expect(parse(`[tags:all.isPublished = true]`)).toEqual({
+			not: {
+				tags: {
+					not: { isPublished: { eq: true } },
+				},
+			},
+		})
+	})
+})

package/tests/cases/unit/queryLanguage/general.spec.tsx

@@ -0,0 +1,59 @@
+import { expect, it, describe } from 'vitest'
+import { GraphQlBuilder } from '@contember/client'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+
+describe('query language parser', () => {
+	it('shoud parse column value', () => {
+		const env = Environment.create()
+		expect(Parser.parseQueryLanguageExpression('123', 'columnValue', env)).toEqual(123)
+		expect(Parser.parseQueryLanguageExpression('123.456', 'columnValue', env)).toEqual(123.456)
+		expect(Parser.parseQueryLanguageExpression('true', 'columnValue', env)).toEqual(true)
+		expect(Parser.parseQueryLanguageExpression('false', 'columnValue', env)).toEqual(false)
+		expect(Parser.parseQueryLanguageExpression('null', 'columnValue', env)).toEqual(null)
+		expect(Parser.parseQueryLanguageExpression("'foo'", 'columnValue', env)).toEqual('foo')
+		expect(Parser.parseQueryLanguageExpression(`'foo\\'bar'`, 'columnValue', env)).toEqual("foo'bar")
+		expect(Parser.parseQueryLanguageExpression(`'foo"bar'`, 'columnValue', env)).toEqual(`foo"bar`)
+		expect(Parser.parseQueryLanguageExpression(`'foo\\"bar'`, 'columnValue', env)).toEqual(`foo"bar`)
+		expect(Parser.parseQueryLanguageExpression('"foo"', 'columnValue', env)).toEqual('foo')
+		expect(Parser.parseQueryLanguageExpression(`"foo\\"bar"`, 'columnValue', env)).toEqual('foo"bar')
+		expect(Parser.parseQueryLanguageExpression(`"foo\\'bar"`, 'columnValue', env)).toEqual("foo'bar")
+		expect(Parser.parseQueryLanguageExpression(`"foo'bar"`, 'columnValue', env)).toEqual("foo'bar")
+	})
+
+	it('should resolve variables adhering to the principle maximal munch', () => {
+		const environment = Environment.create().withVariables({
+			ab: 456,
+			a: 123,
+			x: 'x',
+			lit: new GraphQlBuilder.GraphQlLiteral('lit'),
+			literal: new GraphQlBuilder.GraphQlLiteral('literal'),
+		})
+		expect(
+			Parser.parseQueryLanguageExpression(
+				'a(a=$a).field(ab = $ab, literalColumn = $literal).x(x = truecolor).foo',
+				'relativeSingleField',
+				environment,
+			),
+		).toEqual({
+			field: 'foo',
+			hasOneRelationPath: [
+				{
+					field: 'a',
+					filter: undefined,
+					reducedBy: { a: 123 },
+				},
+				{
+					field: 'field',
+					filter: undefined,
+					reducedBy: { ab: 456, literalColumn: 'literal' },
+				},
+				{
+					field: 'x',
+					filter: undefined,
+					reducedBy: { x: 'truecolor' },
+				},
+			],
+		})
+	})
+})

package/tests/cases/unit/queryLanguage/orderBy.spec.tsx

@@ -0,0 +1,48 @@
+import { expect, it, describe } from 'vitest'
+import { GraphQlBuilder } from '@contember/client'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+
+const parse = (input: string) => {
+	return Parser.parseQueryLanguageExpression(input, 'orderBy', Environment.create())
+}
+
+describe('orderBy QueryLanguage parser', () => {
+	it('should parse single field names', () => {
+		expect(parse('fooName')).toEqual([{ fooName: 'asc' }])
+	})
+
+	it('should parse nested field names', () => {
+		expect(parse('fooName.barName.bazName')).toEqual([
+			{ fooName: { barName: { bazName: 'asc' } } },
+		])
+	})
+
+	it('should parse multiple field names', () => {
+		expect(parse('foo.bar, baz, x.y.z')).toEqual([
+			{ foo: { bar: 'asc' } },
+			{ baz: 'asc' },
+			{ x: { y: { z: 'asc' } } },
+		])
+	})
+
+	it('should parse order directions', () => {
+		expect(parse('foo asc, bar desc')).toEqual([
+			{ foo: 'asc' },
+			{ bar: 'desc' },
+		])
+
+		expect(parse('foo.bar asc, a.b.c desc')).toEqual([
+			{ foo: { bar: 'asc' } },
+			{ a: { b: { c: 'desc' } } },
+		])
+	})
+
+	it('should parse order with odd whitespace use', () => {
+		expect(parse('  \t foo.bar ,baz desc, \t x.y.z\t  \t  desc   ')).toEqual([
+			{ foo: { bar: 'asc' } },
+			{ baz: 'desc' },
+			{ x: { y: { z: 'desc' } } },
+		])
+	})
+})

package/tests/cases/unit/queryLanguage/qualifiedEntityList.spec.tsx

@@ -0,0 +1,30 @@
+import { expect, it, describe } from 'vitest'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+
+const parse = (input: string) => {
+	return Parser.parseQueryLanguageExpression(input, 'qualifiedEntityList', Environment.create())
+}
+
+describe('qualified entity list QueryLanguage parser', () => {
+	it('Should parse just the entity name', () => {
+		expect(parse('Author')).toEqual({
+			entityName: 'Author',
+			filter: undefined,
+			hasOneRelationPath: [],
+		})
+	})
+
+	it('should parse a qualified field list up to an entity', () => {
+		expect(parse(`Author[age > 20 && homeTown = 'Prague'].son.sisters(name = 'Jane')`)).toEqual({
+			entityName: 'Author',
+			filter: {
+				and: [{ age: { gt: 20 } }, { homeTown: { eq: 'Prague' } }],
+			},
+			hasOneRelationPath: [
+				{ field: 'son', filter: undefined, reducedBy: undefined },
+				{ field: 'sisters', filter: undefined, reducedBy: { name: 'Jane' } },
+			],
+		})
+	})
+})

package/tests/cases/unit/queryLanguage/qualifiedFieldList.spec.tsx

@@ -0,0 +1,29 @@
+import { expect, it, describe } from 'vitest'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+
+const parse = (input: string) => {
+	return Parser.parseQueryLanguageExpression(input, 'qualifiedFieldList', Environment.create())
+}
+
+describe('qualified field list QueryLanguage parser', () => {
+	it('should parse a qualified field list in its simplest form', () => {
+		expect(parse('Author.name')).toEqual({
+			entityName: 'Author',
+			filter: undefined,
+			hasOneRelationPath: [],
+			field: 'name',
+		})
+	})
+
+	it('should parse a complete qualified field list', () => {
+		expect(parse('Author[age > 20].son.name')).toEqual({
+			entityName: 'Author',
+			filter: {
+				age: { gt: 20 },
+			},
+			hasOneRelationPath: [{ field: 'son', filter: undefined, reducedBy: undefined }],
+			field: 'name',
+		})
+	})
+})

package/tests/cases/unit/queryLanguage/relativeEntityList.spec.tsx

@@ -0,0 +1,49 @@
+import { expect, it, describe } from 'vitest'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+import type { ParsedRelativeEntityList } from '../../../../src/queryLanguage/ParserResults'
+
+const parse = (input: string): ParsedRelativeEntityList => {
+	return Parser.parseQueryLanguageExpression(input, 'relativeEntityList', Environment.create())
+}
+
+describe('relative entity list QueryLanguage parser', () => {
+	it('should parse unconstrained fields', () => {
+		expect(parse('foo.bar.baz')).toEqual({
+			hasOneRelationPath: [
+				{ field: 'foo', filter: undefined, reducedBy: undefined },
+				{ field: 'bar', filter: undefined, reducedBy: undefined },
+			],
+			hasManyRelation: {
+				field: 'baz',
+				filter: undefined,
+			},
+		})
+	})
+
+	it('should parse simple conditions', () => {
+		expect(parse('foo[bar = 123]')).toEqual({
+			hasOneRelationPath: [],
+			hasManyRelation: {
+				field: 'foo',
+				filter: {
+					bar: { eq: 123 },
+				},
+			},
+		})
+	})
+
+	it('should parse multiple filter conditions', () => {
+		const expected = {
+			hasOneRelationPath: [],
+			hasManyRelation: {
+				field: 'foo',
+				filter: {
+					and: [{ bar: { eq: 'value' } }, { baz: { gte: 456 } }],
+				},
+			},
+		}
+		expect(parse("foo[bar = 'value'][baz >= 456]")).toEqual(expected)
+		expect(parse("foo[bar = 'value' && baz >= 456]")).toEqual(expected)
+	})
+})

package/tests/cases/unit/queryLanguage/singleRelativeField.spec.tsx

@@ -0,0 +1,132 @@
+import { expect, it, describe } from 'vitest'
+import { GraphQlLiteral } from '@contember/client'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+
+const parse = (input: string) => {
+	return Parser.parseQueryLanguageExpression(input, 'relativeSingleField', Environment.create())
+}
+
+describe('single relative fields QueryLanguage parser', () => {
+	it('should parse single field names', () => {
+		expect(parse('fooName')).toEqual({
+			field: 'fooName',
+			hasOneRelationPath: [],
+		})
+	})
+
+	it('should parse single relation with a name', () => {
+		expect(parse('fooRelation.fooName')).toEqual({
+			field: 'fooName',
+			hasOneRelationPath: [
+				{
+					field: 'fooRelation',
+					filter: undefined,
+					reducedBy: undefined,
+				},
+			],
+		})
+	})
+
+	it('should parse a chain of fields without wheres', () => {
+		expect(parse('foo.bar.baz.name')).toEqual({
+			field: 'name',
+			hasOneRelationPath: [
+				{
+					field: 'foo',
+					filter: undefined,
+					reducedBy: undefined,
+				},
+				{
+					field: 'bar',
+					filter: undefined,
+					reducedBy: undefined,
+				},
+				{
+					field: 'baz',
+					filter: undefined,
+					reducedBy: undefined,
+				},
+			],
+		})
+	})
+
+	it('should parse unique where', () => {
+		expect(parse("foo.bar(a='b').name")).toEqual({
+			field: 'name',
+			hasOneRelationPath: [
+				{
+					field: 'foo',
+					filter: undefined,
+					reducedBy: undefined,
+				},
+				{
+					field: 'bar',
+					filter: undefined,
+					reducedBy: {
+						a: 'b',
+					},
+				},
+			],
+		})
+	})
+
+	it('should parse composite unique where', () => {
+		expect(parse("foo(a='b', bar = Literal).name")).toEqual({
+			field: 'name',
+			hasOneRelationPath: [
+				{
+					field: 'foo',
+					filter: undefined,
+					reducedBy: {
+						a: 'b',
+						bar: 'Literal',
+					},
+				},
+			],
+		})
+	})
+
+	it('should reject duplicate fields in unique where', () => {
+		expect(() => parse("foo(a='b', a = 123).name")).toThrowError(/duplicate/i)
+	})
+
+	it('should reject relation fields at the end', () => {
+		expect(() => parse("foo(a='b')")).toThrowError(/relation/i)
+	})
+
+	it('should parse nested unique where', () => {
+		expect(parse('foo(nested.structure.is.deep = 123, nested.structure.be.indeed.not.shallow = baz).name')).toEqual({
+			field: 'name',
+			hasOneRelationPath: [
+				{
+					field: 'foo',
+					filter: undefined,
+					reducedBy: {
+						nested: {
+							structure: {
+								is: {
+									deep: 123,
+								},
+								be: {
+									indeed: {
+										not: {
+											shallow: 'baz',
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			],
+		})
+	})
+
+	it('should reject malformed nested unique where', () => {
+		expect(() => parse('foo(nested.field = 123, nested.field.treated.as.relation = baz).name')).toThrowError(
+			/'nested\.field'/i,
+		)
+		expect(() => parse('foo(nested.field = 123, nested.field = baz).name')).toThrowError(/'nested\.field'/i)
+	})
+})

package/tests/cases/unit/queryLanguage/taggedMap.spec.tsx

@@ -0,0 +1,41 @@
+import { expect, it, describe } from 'vitest'
+import { Environment } from '../../../../src/environment'
+import { Parser } from '../../../../src/queryLanguage'
+import type { ParsedTaggedMap } from '../../../../src/queryLanguage/ParserResults'
+
+const parse = (input: string): ParsedTaggedMap => {
+	return Parser.parseQueryLanguageExpression(input, 'taggedMap', Environment.create())
+}
+
+describe('tagged map QueryLanguage parser', () => {
+	it('should parse literal parameters', () => {
+		expect(parse("foo(bar: 'lorem')")).toEqual({
+			name: 'foo',
+			entries: [
+				{
+					key: 'bar',
+					value: {
+						type: 'literal',
+						value: 'lorem',
+					},
+				},
+			],
+
+		})
+	})
+
+	it('should parse variable parameters', () => {
+		expect(parse('foo(bar: $lorem.ipsum)')).toEqual({
+			name: 'foo',
+			entries: [
+				{
+					key: 'bar',
+					value: {
+						type: 'variable',
+						value: 'lorem.ipsum',
+					},
+				},
+			],
+		})
+	})
+})

package/tests/tsconfig.json

@@ -0,0 +1,10 @@
+{
+	"extends": "../../../tsconfig.settings.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"emitDeclarationOnly": false
+	},
+	"references": [
+		{ "path": "../src" },
+	],
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"files": [],
+	"include": [],
+	"references": [
+		{ "path": "./src" },
+		{ "path": "./tests" },
+	],
+}

package/tsdoc.json

@@ -0,0 +1,6 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+	"extends": [
+		"../../tsdoc.json"
+	]
+}