@contember/engine-content-api 2.1.0-beta.2 → 2.2.0-alpha.2

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

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'bun:test'
+import { Kind } from 'graphql'
+import { CustomTypesProvider } from '../../../src/index.js'
+
+describe('decimal graphql type', () => {
+	const decimalType = new CustomTypesProvider().decimalType
+
+	it('accepts a plain decimal string and trims it', () => {
+		expect(decimalType.parseValue('123.45')).toEqual('123.45')
+		expect(decimalType.parseValue('  -0.001  ')).toEqual('-0.001')
+		expect(decimalType.parseValue('+42')).toEqual('+42')
+		expect(decimalType.parseValue('.5')).toEqual('.5')
+		expect(decimalType.parseValue('5.')).toEqual('5.')
+	})
+
+	it('accepts scientific notation', () => {
+		expect(decimalType.parseValue('1.5e10')).toEqual('1.5e10')
+		expect(decimalType.parseValue('1.5E-10')).toEqual('1.5E-10')
+		expect(decimalType.parseValue('-2e+3')).toEqual('-2e+3')
+	})
+
+	it('normalizes a JSON number input to a string', () => {
+		expect(decimalType.parseValue(123.45)).toEqual('123.45')
+		expect(decimalType.parseValue(0)).toEqual('0')
+		expect(decimalType.parseValue(-7)).toEqual('-7')
+	})
+
+	it('rejects an invalid decimal string', () => {
+		expect(() => decimalType.parseValue('abc')).toThrow()
+		expect(() => decimalType.parseValue('1.2.3')).toThrow()
+		expect(() => decimalType.parseValue('')).toThrow()
+		expect(() => decimalType.parseValue('1,000')).toThrow()
+		expect(() => decimalType.parseValue('0x10')).toThrow()
+	})
+
+	it('rejects non-finite numbers', () => {
+		expect(() => decimalType.parseValue(NaN)).toThrow()
+		expect(() => decimalType.parseValue(Infinity)).toThrow()
+		expect(() => decimalType.parseValue(-Infinity)).toThrow()
+	})
+
+	it('rejects non-string, non-number values', () => {
+		expect(() => decimalType.parseValue(true)).toThrow()
+		expect(() => decimalType.parseValue(null)).toThrow()
+		expect(() => decimalType.parseValue({})).toThrow()
+	})
+
+	it('serializes preserving exact text (incl. trailing zeros)', () => {
+		// The DB returns the full-scale numeric text representation; it must pass through untouched.
+		expect(decimalType.serialize('123.450000000')).toEqual('123.450000000')
+		expect(decimalType.serialize('0.000000000')).toEqual('0.000000000')
+		expect(decimalType.serialize('-123456789123.456')).toEqual('-123456789123.456')
+	})
+
+	it('parses string, int and float literals', () => {
+		expect(decimalType.parseLiteral({ kind: Kind.STRING, value: '123.45' } as any, undefined)).toEqual('123.45')
+		expect(decimalType.parseLiteral({ kind: Kind.INT, value: '42' } as any, undefined)).toEqual('42')
+		expect(decimalType.parseLiteral({ kind: Kind.FLOAT, value: '1.5' } as any, undefined)).toEqual('1.5')
+	})
+
+	it('rejects non-numeric literals', () => {
+		expect(() => decimalType.parseLiteral({ kind: Kind.BOOLEAN, value: true } as any, undefined)).toThrow()
+		expect(() => decimalType.parseLiteral({ kind: Kind.NULL } as any, undefined)).toThrow()
+	})
+})

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

@@ -1,14 +1,14 @@
-import { ColumnValueResolver, Dependencies, InputPreValidator, ValidationDataSelector } from '../../../src/input-validation'
+import { ColumnValueResolver, Dependencies, InputPreValidator, ValidationDataSelector } from '../../../src/input-validation/index.js'
 import { InputValidation as v, SchemaBuilder, SchemaDefinition } from '@contember/schema-definition'
 import { Input, Model, Validation, Value } from '@contember/schema'
-import { EntityRulesResolver } from '../../../src'
+import { EntityRulesResolver } from '../../../src/index.js'
 import { getEntity } from '@contember/schema-utils'
-import { Mapper } from '../../../src/mapper'
-import { createMock } from '../../src/utils'
-import { testUuid } from '../../src/testUuid'
+import { Mapper } from '../../../src/mapper/index.js'
+import { createMock } from '../../src/utils.js'
+import { testUuid } from '../../src/testUuid.js'
 import { describe, it } from 'bun:test'
 import { SchemaDefinition as def } from '@contember/schema-definition'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 type PrimaryValueExpectation = { entity: string; where: Input.UniqueWhere; result: Value.PrimaryValue }
 type SelectExpectation = {
@@ -440,4 +440,99 @@ describe('Input pre-validator', () => {
 		})
 		assert.deepStrictEqual(result, [])
 	})
+
+	describe('JSON schema on JSON column', () => {
+		const model = SchemaDefinition.createModel(JsonSchemaModelDefinition)
+
+		it('accepts a valid JSON value on create', async () => {
+			const validator = createValidator({ model, validation: {} })
+			const result = await validator.validateCreate({
+				entity: getEntity(model, 'Product'),
+				data: {
+					meta: { color: 'red', size: 42 },
+				},
+				overRelation: null,
+				path: [],
+				mapper,
+			})
+			assert.deepStrictEqual(result, [])
+		})
+
+		it('rejects an invalid JSON value on create', async () => {
+			const validator = createValidator({ model, validation: {} })
+			const result = await validator.validateCreate({
+				entity: getEntity(model, 'Product'),
+				data: {
+					meta: { size: 'not-a-number' },
+				},
+				overRelation: null,
+				path: [],
+				mapper,
+			})
+			assert.deepStrictEqual(result, [
+				{
+					path: [{ field: 'meta' }],
+					message: { text: '/color: Required property is missing' },
+				},
+				{
+					path: [{ field: 'meta' }],
+					message: { text: '/size: Expected type number, got string' },
+				},
+			])
+		})
+
+		it('rejects an invalid JSON value on update', async () => {
+			const validator = createValidator({ model, validation: {} })
+			const result = await validator.validateUpdate({
+				entity: getEntity(model, 'Product'),
+				data: {
+					meta: { color: 123 },
+				},
+				where: { id: testUuid(1) },
+				path: [],
+				mapper,
+			})
+			assert.deepStrictEqual(result, [
+				{
+					path: [{ field: 'meta' }],
+					message: { text: '/color: Expected type string, got number' },
+				},
+			])
+		})
+
+		it('skips null and absent values', async () => {
+			const validator = createValidator({ model, validation: {} })
+			const resultNull = await validator.validateUpdate({
+				entity: getEntity(model, 'Product'),
+				data: { meta: null },
+				where: { id: testUuid(1) },
+				path: [],
+				mapper,
+			})
+			assert.deepStrictEqual(resultNull, [])
+
+			const resultAbsent = await validator.validateUpdate({
+				entity: getEntity(model, 'Product'),
+				data: {},
+				where: { id: testUuid(1) },
+				path: [],
+				mapper,
+			})
+			assert.deepStrictEqual(resultAbsent, [])
+		})
+	})
 })
+
+namespace JsonSchemaModelDefinition {
+	export class Product {
+		name = def.stringColumn()
+		meta = def.jsonColumn().schema({
+			type: 'object',
+			properties: {
+				color: { type: 'string' },
+				size: { type: 'number' },
+			},
+			required: ['color'],
+		})
+	}
+}

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

@@ -8,10 +8,10 @@ import {
 	evaluateValidation,
 	QueryAstFactory,
 	ValidationContext,
-} from '../../../src/input-validation'
-import { FieldNode, ObjectNode } from '../../../src/inputProcessing'
+} from '../../../src/input-validation/index.js'
+import { FieldNode, ObjectNode } from '../../../src/inputProcessing/index.js'
 import { describe, expect, it } from 'bun:test'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 describe('input validation tests', () => {
 	it('evaluates rule', () => {

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

@@ -0,0 +1,115 @@
+import { describe, it } from 'bun:test'
+import { assert } from '../../src/assert.js'
+import { validateJsonSchema } from '../../../src/input-validation/JsonSchemaValidator.js'
+
+describe('JSON schema validator', () => {
+	it('validates type', () => {
+		assert.deepStrictEqual(validateJsonSchema({ type: 'string' }, 'hello'), [])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'string' }, 42), [
+			{ path: '', message: 'Expected type string, got number' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'integer' }, 42), [])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'integer' }, 4.2), [
+			{ path: '', message: 'Expected type integer, got number' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ type: ['string', 'null'] }, null), [])
+	})
+
+	it('validates enum and const', () => {
+		assert.deepStrictEqual(validateJsonSchema({ enum: ['a', 'b'] }, 'a'), [])
+		assert.deepStrictEqual(validateJsonSchema({ enum: ['a', 'b'] }, 'c'), [
+			{ path: '', message: 'Value is not one of the allowed values' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ const: 5 }, 5), [])
+		assert.deepStrictEqual(validateJsonSchema({ const: 5 }, 6), [
+			{ path: '', message: 'Value does not match the expected constant' },
+		])
+	})
+
+	it('validates string constraints', () => {
+		assert.deepStrictEqual(validateJsonSchema({ type: 'string', minLength: 2, maxLength: 4 }, 'abc'), [])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'string', minLength: 5 }, 'abc'), [
+			{ path: '', message: 'String is shorter than 5 characters' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'string', pattern: '^[a-z]+$' }, 'ABC'), [
+			{ path: '', message: 'String does not match pattern ^[a-z]+$' },
+		])
+	})
+
+	it('validates number constraints', () => {
+		assert.deepStrictEqual(validateJsonSchema({ type: 'number', minimum: 0, maximum: 10 }, 5), [])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'number', minimum: 10 }, 5), [
+			{ path: '', message: 'Value is less than minimum 10' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ type: 'number', multipleOf: 3 }, 7), [
+			{ path: '', message: 'Value is not a multiple of 3' },
+		])
+	})
+
+	it('validates objects with properties and required', () => {
+		const schema = {
+			type: 'object',
+			properties: {
+				name: { type: 'string' },
+				age: { type: 'integer' },
+			},
+			required: ['name'],
+			additionalProperties: false,
+		}
+		assert.deepStrictEqual(validateJsonSchema(schema, { name: 'Joe', age: 30 }), [])
+		assert.deepStrictEqual(validateJsonSchema(schema, { age: 30 }), [
+			{ path: '/name', message: 'Required property is missing' },
+		])
+		assert.deepStrictEqual(validateJsonSchema(schema, { name: 'Joe', extra: 1 }), [
+			{ path: '/extra', message: 'Additional property is not allowed' },
+		])
+		assert.deepStrictEqual(validateJsonSchema(schema, { name: 5 }), [
+			{ path: '/name', message: 'Expected type string, got number' },
+		])
+	})
+
+	it('validates arrays', () => {
+		const schema = { type: 'array', items: { type: 'number' }, minItems: 1, uniqueItems: true }
+		assert.deepStrictEqual(validateJsonSchema(schema, [1, 2, 3]), [])
+		assert.deepStrictEqual(validateJsonSchema(schema, []), [
+			{ path: '', message: 'Array has fewer than 1 items' },
+		])
+		assert.deepStrictEqual(validateJsonSchema(schema, [1, 'x']), [
+			{ path: '/1', message: 'Expected type number, got string' },
+		])
+		assert.deepStrictEqual(validateJsonSchema(schema, [1, 1]), [
+			{ path: '', message: 'Array items are not unique' },
+		])
+	})
+
+	it('validates nested structures with correct paths', () => {
+		const schema = {
+			type: 'object',
+			properties: {
+				tags: { type: 'array', items: { type: 'object', properties: { id: { type: 'integer' } }, required: ['id'] } },
+			},
+		}
+		assert.deepStrictEqual(validateJsonSchema(schema, { tags: [{ id: 1 }, { id: 'x' }, {}] }), [
+			{ path: '/tags/1/id', message: 'Expected type integer, got string' },
+			{ path: '/tags/2/id', message: 'Required property is missing' },
+		])
+	})
+
+	it('validates combinators', () => {
+		assert.deepStrictEqual(validateJsonSchema({ anyOf: [{ type: 'string' }, { type: 'number' }] }, 5), [])
+		assert.deepStrictEqual(validateJsonSchema({ anyOf: [{ type: 'string' }, { type: 'number' }] }, true), [
+			{ path: '', message: 'Value does not match any of the allowed schemas' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ not: { type: 'string' } }, 5), [])
+		assert.deepStrictEqual(validateJsonSchema({ not: { type: 'string' } }, 'x'), [
+			{ path: '', message: 'Value matches a forbidden schema' },
+		])
+		assert.deepStrictEqual(validateJsonSchema({ oneOf: [{ type: 'number' }, { type: 'integer' }] }, 5), [
+			{ path: '', message: 'Value must match exactly one of the allowed schemas' },
+		])
+	})
+
+	it('ignores unknown keywords', () => {
+		assert.deepStrictEqual(validateJsonSchema({ type: 'string', title: 'Foo', description: 'bar', format: 'email' }, 'x'), [])
+	})
+})

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

@@ -1,8 +1,8 @@
 import { Input, Model } from '@contember/schema'
-import { OrderByHelper } from '../../../src/mapper'
-import { ObjectNode } from '../../../src/inputProcessing'
+import { OrderByHelper } from '../../../src/mapper/index.js'
+import { ObjectNode } from '../../../src/inputProcessing/index.js'
 import { describe, it } from 'bun:test'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 const entity: Model.Entity = {
 	name: 'Foo',

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

@@ -1,9 +1,9 @@
 import { Acl, Model } from '@contember/schema'
-import { PermissionFactory } from '../../../src/acl'
+import { PermissionFactory } from '../../../src/acl/index.js'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { describe, it } from 'bun:test'
 import { emptySchema } from '@contember/schema-utils'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 interface Test {
 	acl: Acl.Schema

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

@@ -1,8 +1,8 @@
-import { PredicateFactory, VariableInjector } from '../../../src/acl'
+import { PredicateFactory, VariableInjector } from '../../../src/acl/index.js'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { describe, it } from 'bun:test'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 namespace TestModel {
 	export class Author {

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

@@ -1,12 +1,12 @@
-import { PermissionFactory, PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl'
+import { PermissionFactory, PredicateFactory, PredicatesInjector, VariableInjector } from '../../../src/acl/index.js'
 import { AclDefinition as acl, createSchema, PermissionsBuilder, SchemaBuilder, SchemaDefinition as def } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { describe, it } from 'bun:test'
-import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
-import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer.js'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer.js'
 import { acceptFieldVisitor, AllowAllPermissionFactory } from '@contember/schema-utils'
-import { testUuid } from '../../src/testUuid'
-import { assert } from '../../src/assert'
+import { testUuid } from '../../src/testUuid.js'
+import { assert } from '../../src/assert.js'
 
 const schema = new SchemaBuilder()
 	.enum('locale', ['cs', 'en'])

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { CustomTypesProvider } from '../../../src'
+import { CustomTypesProvider } from '../../../src/index.js'
 
 describe('uuid graphql type', () => {
 	const customTypesProvider = new CustomTypesProvider()

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

@@ -1,8 +1,8 @@
-import { VariableInjector } from '../../../src/acl'
+import { VariableInjector } from '../../../src/acl/index.js'
 import { SchemaBuilder } from '@contember/schema-definition'
 import { Acl, Model } from '@contember/schema'
 import { describe, it } from 'bun:test'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 describe('Variable injector', () => {
 	it('injects variable', () => {

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

@@ -1,11 +1,11 @@
 import { describe, it } from 'bun:test'
-import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer.js'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
-import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
-import { ConditionBuilder, JoinBuilder, PathFactory, WhereBuilder } from '../../../src/mapper'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer.js'
+import { ConditionBuilder, JoinBuilder, PathFactory, WhereBuilder } from '../../../src/mapper/index.js'
 import { Compiler, SelectBuilder } from '@contember/database'
 import { Input, Schema } from '@contember/schema'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 namespace WhereBuilderModel {
 	export class Author {

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

@@ -1,9 +1,9 @@
 import { describe, it } from 'bun:test'
-import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer'
+import { ConditionOptimizer } from '../../../src/mapper/select/optimizer/ConditionOptimizer.js'
 import { SchemaDefinition as def } from '@contember/schema-definition'
-import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer'
+import { WhereOptimizer } from '../../../src/mapper/select/optimizer/WhereOptimizer.js'
 import { acceptFieldVisitor } from '@contember/schema-utils'
-import { assert } from '../../src/assert'
+import { assert } from '../../src/assert.js'
 
 namespace TestModel {
 	export class Author {

package/tests/src/test.ts

@@ -1,10 +1,10 @@
-import { Acl, Model, Schema, Validation } from '@contember/schema'
-import { Authorizator, ExecutionContainerFactory, GraphQlSchemaBuilderFactory } from '../../src'
+import { Acl, Model, Schema, Settings, Validation } from '@contember/schema'
+import { Authorizator, ExecutionContainerFactory, GraphQlSchemaBuilderFactory } from '../../src/index.js'
 import { AllowAllPermissionFactory, emptySchema } from '@contember/schema-utils'
-import { executeGraphQlTest } from './testGraphql'
+import { executeGraphQlTest } from './testGraphql.js'
 import { Client, emptyDatabaseMetadata } from '@contember/database'
 import { createConnectionMock } from '@contember/database-tester'
-import { createUuidGenerator, testUuid } from './testUuid'
+import { createUuidGenerator, testUuid } from './testUuid.js'
 
 export interface SqlQuery {
 	sql: string
@@ -14,6 +14,7 @@ export interface SqlQuery {
 
 export interface Test {
 	schema: Model.Schema
+	settings?: Settings.Schema
 	validation?: Validation.Schema
 	permissions?: Acl.Permissions
 	variables?: Acl.VariablesMap
@@ -82,7 +83,7 @@ export const execute = async (test: Test) => {
 	const connection = createConnectionMock(test.executes)
 
 	const db = new Client(connection, 'public', {})
-	const schema: Schema = { ...emptySchema, model: test.schema, validation: test.validation || {} }
+	const schema: Schema = { ...emptySchema, model: test.schema, validation: test.validation || {}, settings: test.settings || emptySchema.settings }
 	const providers = {
 		uuid: createUuidGenerator('a456', 0),
 		now: () => new Date('2019-09-04 12:00'),