@contember/schema-utils 2.1.0-beta.2 → 2.2.0-alpha.2

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

@@ -0,0 +1,91 @@
+import { describe, expect, test } from 'bun:test'
+import { collectUnsupportedJsonSchemaKeywords } from '../../../src/index.js'
+
+describe('collectUnsupportedJsonSchemaKeywords', () => {
+	test('accepts a fully supported schema', () => {
+		expect(collectUnsupportedJsonSchemaKeywords({
+			type: 'object',
+			properties: {
+				name: { type: 'string', minLength: 1, maxLength: 10, pattern: '^.+$' },
+				age: { type: 'integer', minimum: 0, maximum: 120 },
+				tags: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 5, uniqueItems: true },
+				kind: { enum: ['a', 'b'] },
+				flag: { const: true },
+			},
+			required: ['name'],
+			additionalProperties: false,
+			minProperties: 1,
+			maxProperties: 10,
+		})).toStrictEqual([])
+	})
+
+	test('accepts combinators', () => {
+		expect(collectUnsupportedJsonSchemaKeywords({
+			allOf: [{ type: 'object' }],
+			anyOf: [{ type: 'string' }, { type: 'number' }],
+			oneOf: [{ const: 1 }, { const: 2 }],
+			not: { type: 'null' },
+		})).toStrictEqual([])
+	})
+
+	test('accepts annotation keywords', () => {
+		expect(collectUnsupportedJsonSchemaKeywords({
+			$schema: 'https://json-schema.org/draft/2020-12/schema',
+			$id: 'https://example.com/x',
+			$comment: 'note',
+			title: 'Title',
+			description: 'Desc',
+			examples: [1, 2],
+			default: 0,
+			readOnly: true,
+			writeOnly: false,
+			deprecated: false,
+			type: 'integer',
+		})).toStrictEqual([])
+	})
+
+	test.each([
+		'$ref',
+		'$defs',
+		'format',
+		'patternProperties',
+		'propertyNames',
+		'dependentRequired',
+		'dependentSchemas',
+		'if',
+		'then',
+		'else',
+		'contains',
+		'prefixItems',
+	])('rejects unsupported keyword %s at the root', keyword => {
+		expect(collectUnsupportedJsonSchemaKeywords({ [keyword]: {} })).toStrictEqual([{ keyword, path: '' }])
+	})
+
+	test('descends into properties, items, additionalProperties and reports a path', () => {
+		expect(collectUnsupportedJsonSchemaKeywords({
+			type: 'object',
+			properties: {
+				a: { type: 'string', format: 'email' },
+			},
+			additionalProperties: { type: 'array', items: { contains: { type: 'number' } } },
+		})).toStrictEqual([
+			{ keyword: 'format', path: '/properties/a' },
+			{ keyword: 'contains', path: '/additionalProperties/items' },
+		])
+	})
+
+	test('descends into combinators', () => {
+		expect(collectUnsupportedJsonSchemaKeywords({
+			anyOf: [{ type: 'string' }, { type: 'object', propertyNames: { pattern: '^x' } }],
+			not: { $ref: '#/x' },
+		})).toStrictEqual([
+			{ keyword: 'propertyNames', path: '/anyOf/1' },
+			{ keyword: '$ref', path: '/not' },
+		])
+	})
+
+	test('boolean schema is valid', () => {
+		expect(collectUnsupportedJsonSchemaKeywords(true)).toStrictEqual([])
+		expect(collectUnsupportedJsonSchemaKeywords(false)).toStrictEqual([])
+	})
+})

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

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'bun:test'
+import { jsonSchemaToTsType } from '../../../src/index.js'
+
+describe('jsonSchemaToTsType', () => {
+	test('scalars', () => {
+		expect(jsonSchemaToTsType({ type: 'string' })).toBe('string')
+		expect(jsonSchemaToTsType({ type: 'integer' })).toBe('number')
+		expect(jsonSchemaToTsType({ type: 'number' })).toBe('number')
+		expect(jsonSchemaToTsType({ type: 'boolean' })).toBe('boolean')
+		expect(jsonSchemaToTsType({ type: 'null' })).toBe('null')
+	})
+
+	test('type union', () => {
+		expect(jsonSchemaToTsType({ type: ['string', 'null'] })).toBe('string | null')
+	})
+
+	test('const and enum', () => {
+		expect(jsonSchemaToTsType({ const: 'x' })).toBe('"x"')
+		expect(jsonSchemaToTsType({ const: 5 })).toBe('5')
+		expect(jsonSchemaToTsType({ enum: ['a', 'b', 1] })).toBe('"a" | "b" | 1')
+	})
+
+	test('object with required and optional properties', () => {
+		expect(jsonSchemaToTsType({
+			type: 'object',
+			properties: {
+				name: { type: 'string' },
+				age: { type: 'integer' },
+			},
+			required: ['name'],
+		})).toBe('{ name: string; age?: number }')
+	})
+
+	test('array of strings', () => {
+		expect(jsonSchemaToTsType({ type: 'array', items: { type: 'string' } })).toBe('readonly (string)[]')
+	})
+
+	test('combinators', () => {
+		expect(jsonSchemaToTsType({ anyOf: [{ type: 'string' }, { type: 'number' }] })).toBe('string | number')
+		expect(jsonSchemaToTsType({ allOf: [{ type: 'object', properties: { a: { type: 'string' } }, required: ['a'] }] }))
+			.toBe('{ a: string }')
+	})
+
+	test('falls back to JSONValue for unexpressible constructs', () => {
+		expect(jsonSchemaToTsType({})).toBe('JSONValue')
+		expect(jsonSchemaToTsType(true)).toBe('JSONValue')
+		expect(jsonSchemaToTsType({ not: { type: 'string' } })).toBe('JSONValue')
+		// object with no declared properties stays JSONValue rather than emitting `{}`
+		expect(jsonSchemaToTsType({ type: 'object' })).toBe('JSONValue')
+		// const of a non-primitive
+		expect(jsonSchemaToTsType({ const: { a: 1 } })).toBe('JSONValue')
+		// unsupported nested item type degrades to JSONValue element rather than failing whole array
+		expect(jsonSchemaToTsType({ type: 'array', items: { not: {} } })).toBe('readonly (JSONValue)[]')
+	})
+})

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

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-import { LaxSchemaConverter } from '../../../src'
+import { LaxSchemaConverter } from '../../../src/index.js'
 
 test('lax schema converter basic', () => {
 	const converter = new LaxSchemaConverter(

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

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-import { MembershipResolver, MembershipValidationErrorType } from '../../../src'
+import { MembershipResolver, MembershipValidationErrorType } from '../../../src/index.js'
 import { Acl } from '@contember/schema'
 
 const id1 = 'bff057b3-11f7-4bc7-abe3-1f2ef266824d'

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { modelSchema } from '../../../src/type-schema'
+import { modelSchema } from '../../../src/type-schema/index.js'
 import { Model } from '@contember/schema'
 
 describe('model schema', () => {

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

@@ -1,6 +1,6 @@
 import { expect, test } from 'bun:test'
 import { Model } from '@contember/schema'
-import { ModelValidator } from '../../../src'
+import { ModelValidator } from '../../../src/index.js'
 import { c, createSchema } from '@contember/schema-definition'
 
 test('"meta" collision', () => {
@@ -92,6 +92,167 @@ test('column name collision', () => {
 	])
 })
 
+namespace CoveringIndexKeyOverlap {
+	@c.Index({ fields: ['title'], include: ['title'] })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('covering index include column overlaps key column', () => {
+	const schema = createSchema(CoveringIndexKeyOverlap)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message: 'Field title cannot be both an index key and an included (covering) column',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
+namespace IndexColumnOptionsNonKey {
+	@c.Index('title')
+	export class Article {
+		title = c.stringColumn()
+		rank = c.intColumn()
+	}
+}
+
+test('index column options reference a non-key column', () => {
+	const schema = createSchema(IndexColumnOptionsNonKey)
+	const article = schema.model.entities.Article
+	// `columnOptions` keys are always index key fields when built through the DSL; inject an invalid
+	// one directly to exercise the guard against hand-written/imported models.
+	const model: Model.Schema = {
+		...schema.model,
+		entities: {
+			...schema.model.entities,
+			Article: {
+				...article,
+				indexes: [{ fields: ['title'], columnOptions: { rank: { order: 'desc' } } }],
+			},
+		},
+	}
+	const validator = new ModelValidator(model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message: 'Column options reference field rank, which is not a key column of the index',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
+namespace IndexDuplicateKeyColumn {
+	@c.Index({ fields: [{ field: 'title' }, { field: 'title', order: 'desc' }] })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('index lists a key column more than once', () => {
+	const schema = createSchema(IndexDuplicateKeyColumn)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message: 'Field title is listed more than once as an index key column',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
+namespace IndexSortOptionsOnNonBtree {
+	@c.Index({ fields: [{ field: 'title', order: 'desc' }], method: 'gin' })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('index sort order on a non-btree method', () => {
+	const schema = createSchema(IndexSortOptionsOnNonBtree)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message: 'Column options (order/nulls) on field title are only supported for btree indexes, not "gin"',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
+namespace IndexInvalidOpClass {
+	@c.Index({ fields: ['title'], opClass: 'gin_trgm_ops); DROP TABLE article; --' })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('index operator class with an invalid (injection-shaped) value', () => {
+	const schema = createSchema(IndexInvalidOpClass)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message:
+				'Invalid index operator class "gin_trgm_ops); DROP TABLE article; --": expected an identifier, optionally schema-qualified (e.g. "public.gin_trgm_ops")',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
+namespace IndexSchemaQualifiedOpClass {
+	@c.Index({ fields: ['title'], method: 'gin', opClass: 'public.gin_trgm_ops' })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('index operator class may be schema-qualified', () => {
+	const schema = createSchema(IndexSchemaQualifiedOpClass)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([])
+})
+
+namespace PartialIndexEmptyPredicate {
+	@c.Index({ fields: ['title'], where: '   ' })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('partial index with empty predicate', () => {
+	const schema = createSchema(PartialIndexEmptyPredicate)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message: 'Index predicate (where) must not be empty.',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
+namespace PartialIndexSemicolonPredicate {
+	@c.Index({ fields: ['title'], where: 'title IS NOT NULL); DROP TABLE article; --' })
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+test('partial index predicate with a statement terminator', () => {
+	const schema = createSchema(PartialIndexSemicolonPredicate)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([
+		{
+			code: 'MODEL_INVALID_INDEX',
+			message: 'Index predicate (where) must not contain ";".',
+			path: ['entities', 'Article', 'indexes'],
+		},
+	])
+})
+
 namespace ViewRelations {
 	@c.View('SELECT 1')
 	export class Foo {
@@ -109,3 +270,87 @@ test('view relations', () => {
 	const validator = new ModelValidator(schema.model)
 	expect(validator.validate()).toStrictEqual([])
 })
+
+namespace SupportedJsonSchema {
+	export class Foo {
+		data = c.jsonColumn().schema({
+			type: 'object',
+			title: 'Some data',
+			description: 'annotation keywords are allowed',
+			properties: {
+				name: { type: 'string', minLength: 1 },
+				tags: { type: 'array', items: { type: 'string' }, uniqueItems: true },
+			},
+			required: ['name'],
+			additionalProperties: false,
+		})
+	}
+}
+
+test('json schema with supported keywords passes', () => {
+	const schema = createSchema(SupportedJsonSchema)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([])
+})
+
+namespace UnsupportedJsonSchemaKeyword {
+	export class Foo {
+		data = c.jsonColumn().schema({
+			type: 'string',
+			format: 'email',
+		})
+	}
+}
+
+test('json schema with an unsupported keyword fails', () => {
+	const schema = createSchema(UnsupportedJsonSchemaKeyword)
+	const validator = new ModelValidator(schema.model)
+	const errors = validator.validate()
+	expect(errors).toHaveLength(1)
+	expect(errors[0].code).toBe('MODEL_INVALID_JSON_SCHEMA')
+	expect(errors[0].path).toStrictEqual(['entities', 'Foo', 'data'])
+	expect(errors[0].message).toContain('unsupported keyword "format"')
+	expect(errors[0].message).toContain('at the schema root')
+})
+
+namespace UnsupportedJsonSchemaKeywordNested {
+	export class Foo {
+		data = c.jsonColumn().schema({
+			type: 'object',
+			properties: {
+				ref: { $ref: '#/definitions/Bar' },
+			},
+		})
+	}
+}
+
+test('json schema reports unsupported keyword nested in properties with a path', () => {
+	const schema = createSchema(UnsupportedJsonSchemaKeywordNested)
+	const validator = new ModelValidator(schema.model)
+	const errors = validator.validate()
+	expect(errors).toHaveLength(1)
+	expect(errors[0].code).toBe('MODEL_INVALID_JSON_SCHEMA')
+	expect(errors[0].message).toContain('unsupported keyword "$ref"')
+	expect(errors[0].message).toContain('at "/properties/ref"')
+})
+
+namespace UnsupportedJsonSchemaKeywordInCombinator {
+	export class Foo {
+		data = c.jsonColumn().schema({
+			anyOf: [
+				{ type: 'string' },
+				{ type: 'object', patternProperties: { '^x': { type: 'number' } } },
+			],
+		})
+	}
+}
+
+test('json schema reports unsupported keyword inside a combinator', () => {
+	const schema = createSchema(UnsupportedJsonSchemaKeywordInCombinator)
+	const validator = new ModelValidator(schema.model)
+	const errors = validator.validate()
+	expect(errors).toHaveLength(1)
+	expect(errors[0].code).toBe('MODEL_INVALID_JSON_SCHEMA')
+	expect(errors[0].message).toContain('unsupported keyword "patternProperties"')
+	expect(errors[0].message).toContain('at "/anyOf/1"')
+})

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

@@ -0,0 +1,69 @@
+import { c, createSchema } from '@contember/schema-definition'
+import { expect, test } from 'bun:test'
+import { Model, Schema } from '@contember/schema'
+import { DefinitionCodeGenerator } from '../../../src/definition-generator/DefinitionCodeGenerator.js'
+
+namespace NumericModel {
+	export class Product {
+		price = c.numericColumn(20, 9).notNull()
+		discount = c.numericColumn(5, 2)
+	}
+}
+
+// Immutably overrides the stored columnType of a single Product column, so we can
+// exercise the regex / fallback branches without writing to the readonly fields map.
+const withColumnType = (schema: Schema, field: string, columnType: string): Schema => {
+	const entity = schema.model.entities.Product
+	const column = entity.fields[field] as Model.AnyColumn
+	return {
+		...schema,
+		model: {
+			...schema.model,
+			entities: {
+				...schema.model.entities,
+				Product: {
+					...entity,
+					fields: {
+						...entity.fields,
+						[field]: { ...column, columnType },
+					},
+				},
+			},
+		},
+	}
+}
+
+test('reverse codegen round-trips numericColumn(precision, scale)', () => {
+	const schema = createSchema(NumericModel)
+	const generated = new DefinitionCodeGenerator().generate(schema)
+
+	expect(generated).toContain('price = c.numericColumn(20, 9).notNull()')
+	expect(generated).toContain('discount = c.numericColumn(5, 2)')
+})
+
+test('reverse codegen parses arbitrary whitespace/casing in numeric(p, s)', () => {
+	// An equivalent-but-unusual form must still be parsed by the regex.
+	const schema = withColumnType(createSchema(NumericModel), 'price', 'NUMERIC ( 30 ,  10 )')
+
+	const generated = new DefinitionCodeGenerator().generate(schema)
+	expect(generated).toContain('price = c.numericColumn(30, 10).notNull()')
+})
+
+test('reverse codegen falls back when columnType is not parseable', () => {
+	// An unparseable columnType (e.g. a domain type) must fall back to a default
+	// numericColumn(...) plus an explicit columnType(...).
+	const schema = withColumnType(createSchema(NumericModel), 'price', 'my_money_domain')
+
+	const generated = new DefinitionCodeGenerator().generate(schema)
+	expect(generated).toContain("price = c.numericColumn(30, 10).columnType('my_money_domain').notNull()")
+})
+
+test('reverse codegen fallback omits columnType when it equals the default', () => {
+	// A bare "numeric" is not matched by the precision/scale regex, but equals the default
+	// column type, so no redundant columnType(...) should be emitted.
+	const schema = withColumnType(createSchema(NumericModel), 'discount', 'numeric')
+
+	const generated = new DefinitionCodeGenerator().generate(schema)
+	expect(generated).toContain('discount = c.numericColumn(30, 10)')
+	expect(generated).not.toContain("columnType('numeric')")
+})

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

@@ -1,5 +1,5 @@
 import { beforeAll, describe, expect, test } from 'bun:test'
-import { printJsValue } from '../../../src/utils/printJsValue'
+import { printJsValue } from '../../../src/utils/printJsValue.js'
 
 describe('printJsValue', () => {
 	test('string', () => {

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

@@ -1,15 +1,15 @@
-import { createSchema } from '@contember/schema-definition'
+import { c, createSchema } from '@contember/schema-definition'
 import { expect, test } from 'bun:test'
-import * as basic from './schemas/basic'
-import * as complex from './schemas/complex'
-import * as relations from './schemas/relations'
-import * as unique from './schemas/unique'
-import * as enum_ from './schemas/enum'
-import * as acl from './schemas/acl'
-import * as view from './schemas/view'
+import * as basic from './schemas/basic.js'
+import * as complex from './schemas/complex.js'
+import * as relations from './schemas/relations.js'
+import * as unique from './schemas/unique.js'
+import * as enum_ from './schemas/enum.js'
+import * as acl from './schemas/acl.js'
+import * as view from './schemas/view.js'
 import { readFile, writeFile } from 'fs/promises'
 import { join } from 'path'
-import { DefinitionCodeGenerator } from '../../../src/definition-generator/DefinitionCodeGenerator'
+import { DefinitionCodeGenerator } from '../../../src/definition-generator/DefinitionCodeGenerator.js'
 import { dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -36,3 +36,40 @@ for (const [name, def] of tests) {
 		}
 	})
 }
+
+namespace IndexOptionsSchema {
+	@c.Index({ fields: ['title'], opClass: 'text_pattern_ops' })
+	@c.Index({ fields: ['title'], method: 'gin', opClass: 'gin_trgm_ops' })
+	@c.Index({ fields: ['title'], include: ['content'], where: 'content IS NOT NULL' })
+	export class Article {
+		title = c.stringColumn()
+		content = c.stringColumn()
+	}
+}
+
+test('definition generator preserves index opClass, include and where options', () => {
+	const generator = new DefinitionCodeGenerator()
+	const generated = generator.generate(createSchema(IndexOptionsSchema))
+	// regression (ARCH-1): opClass used to be dropped on regeneration, silently degrading e.g. trigram search
+	expect(generated).toContain(`@c.Index({ fields: ['title'], opClass: 'text_pattern_ops' })`)
+	expect(generated).toContain(`@c.Index({ fields: ['title'], method: 'gin', opClass: 'gin_trgm_ops' })`)
+	expect(generated).toContain(`@c.Index({ fields: ['title'], include: ['content'], where: 'content IS NOT NULL' })`)
+	// opClass alone must force the options form, never the positional short form that would drop it
+	expect(generated).not.toContain(`@c.Index('title')`)
+})
+
+namespace IndexColumnOptionsGenSchema {
+	@c.Index({ fields: ['title', { field: 'rank', order: 'desc', nulls: 'last' }] })
+	@c.Index({ fields: [{ field: 'title', opClass: 'text_pattern_ops' }] })
+	export class Article {
+		title = c.stringColumn()
+		rank = c.intColumn()
+	}
+}
+
+test('definition generator round-trips per-column index options', () => {
+	const generator = new DefinitionCodeGenerator()
+	const generated = generator.generate(createSchema(IndexColumnOptionsGenSchema))
+	expect(generated).toContain(`@c.Index({ fields: ['title', { field: 'rank', order: 'desc', nulls: 'last' }] })`)
+	expect(generated).toContain(`@c.Index({ fields: [{ field: 'title', opClass: 'text_pattern_ops' }] })`)
+})

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

@@ -1,8 +1,8 @@
 import { describe, expect, test } from 'bun:test'
-import { conditionSchema } from '../../../src/type-schema'
+import { conditionSchema } from '../../../src/type-schema/index.js'
 import { Model } from '@contember/schema'
 import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
-import { whereSchema } from '../../../src/type-schema/where'
+import { whereSchema } from '../../../src/type-schema/where.js'
 
 namespace MyModel {
 	export class Article {