@contember/schema-utils 2.0.0-alpha.9 → 2.0.0-beta.2

package/src/schemaChecksum.ts

@@ -0,0 +1,12 @@
+import { Schema } from '@contember/schema'
+import crypto from 'node:crypto'
+
+
+export const calculateSchemaChecksum = (schema: Schema): string => {
+	const jsonSchema = JSON.stringify(schema)
+
+	return crypto
+		.createHash('md5')
+		.update(jsonSchema)
+		.digest('hex')
+}

package/src/type-schema/model.ts

@@ -1,5 +1,6 @@
 import * as Typesafe from '@contember/typesafe'
 import { Model } from '@contember/schema'
+import { ParseError } from '@contember/typesafe'
 
 const orderBySchema = Typesafe.array(Typesafe.object({
 	path: Typesafe.array(Typesafe.string),
@@ -118,7 +119,12 @@ const columnSchema = Typesafe.intersection(
 	Typesafe.object({
 		name: Typesafe.string,
 		columnName: Typesafe.string,
-		columnType: Typesafe.string,
+		columnType: Typesafe.transform(Typesafe.string, (it, raw, path) => {
+			if (!it.replaceAll(/\s+/g, '').match(/^[\w_]+(?:\(\w+(?:,\w+)*\))?\w*(?:"[^"]+")?(\[])*$/)) {
+				throw ParseError.format(it, path, 'valid column type')
+			}
+			return it
+		}),
 		nullable: Typesafe.boolean,
 		type: Typesafe.enumeration<Model.ColumnType>(...Object.values(Model.ColumnType)),
 	}),

package/src/type-schema/settings.ts

@@ -9,6 +9,7 @@ export const settingsSchema = Typesafe.partial({
 	}),
 	content: Typesafe.partial({
 		useExistsInHasManyFilter: Typesafe.boolean,
+		fullDateTimeResponse: Typesafe.boolean,
 		shortDateResponse: Typesafe.boolean,
 	}),
 })

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

@@ -1,4 +1,4 @@
-import { assert, test, describe } from 'vitest'
+import { expect, test, describe } from 'bun:test'
 import { conditionSchema } from '../../../src/type-schema'
 import { Model } from '@contember/schema'
 
@@ -7,28 +7,28 @@ describe('condition schema', () => {
 		const condition = {
 			and: [{ isNull: true }, { not: { isNull: false } }],
 		}
-		assert.deepStrictEqual(conditionSchema()(condition), condition)
+		expect(conditionSchema()(condition)).toStrictEqual(condition)
 	})
 
 	test('accept string-only condition for unknown type', () => {
 		const condition = {
 			containsCI: 'foo',
 		}
-		assert.deepStrictEqual(conditionSchema()(condition), condition)
+		expect(conditionSchema()(condition)).toStrictEqual(condition)
 	})
 
 	test('accept string-only condition for string type', () => {
 		const condition = {
 			containsCI: 'foo',
 		}
-		assert.deepStrictEqual(conditionSchema(Model.ColumnType.String)(condition), condition)
+		expect(conditionSchema(Model.ColumnType.String)(condition)).toStrictEqual(condition)
 	})
 
 	test('reject string-only condition for int type', () => {
 		const condition = {
 			containsCI: 'foo',
 		}
-		assert.throw(() => conditionSchema(Model.ColumnType.Int)(condition), 'value at root: extra property containsCI found')
+		expect(() => conditionSchema(Model.ColumnType.Int)(condition)).toThrow('value at root: extra property containsCI found')
 	})
 
 
@@ -36,20 +36,20 @@ describe('condition schema', () => {
 		const condition = {
 			eq: 'foo',
 		}
-		assert.deepStrictEqual(conditionSchema()(condition), condition)
+		expect(conditionSchema()(condition)).toStrictEqual(condition)
 	})
 
 	test('accept non-json condition for string type', () => {
 		const condition = {
 			eq: 'foo',
 		}
-		assert.deepStrictEqual(conditionSchema(Model.ColumnType.String)(condition), condition)
+		expect(conditionSchema(Model.ColumnType.String)(condition)).toStrictEqual(condition)
 	})
 
 	test('reject non-json condition for json type', () => {
 		const condition = {
 			eq: 'foo',
 		}
-		assert.throw(() => conditionSchema(Model.ColumnType.Json)(condition), 'value at root: extra property eq found')
+		expect(() => conditionSchema(Model.ColumnType.Json)(condition)).toThrow('value at root: extra property eq found')
 	})
 })

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

@@ -1,4 +1,4 @@
-import { assert, describe, test } from 'vitest'
+import { expect, describe, test } from 'bun:test'
 import { compareArraysIgnoreOrder } from '../../../src'
 
 describe('deep compare', () => {
@@ -10,7 +10,7 @@ describe('deep compare', () => {
 			{ lorem: 'ipsum' },
 			{ foo: 'bar' },
 		], [])
-		assert.deepStrictEqual(actual, [])
+		expect(actual).toStrictEqual([])
 	})
 
 	test('compare array ignore order - missing in A', () => {
@@ -21,7 +21,7 @@ describe('deep compare', () => {
 			{ lorem: 'ipsum' },
 			{ foo: 'bar' },
 		], [])
-		assert.deepStrictEqual(actual, [{
+		expect(actual).toStrictEqual([{
 			path: [],
 			message: 'Array item: {"lorem":"ipsum"} not found in [{"foo":"bar"}]',
 		}])
@@ -35,7 +35,7 @@ describe('deep compare', () => {
 			{ lorem: 'ipsum' },
 			{ lorem: 'ipsum' },
 		], [])
-		assert.deepStrictEqual(actual, [{
+		expect(actual).toStrictEqual([{
 			path: [],
 			message: 'Array item: {"foo":"bar"} not found in [{"lorem":"ipsum"},{"lorem":"ipsum"}]',
 		}],

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

@@ -1,4 +1,4 @@
-import { expect, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { LaxSchemaConverter } from '../../../src'
 
 test('lax schema converter basic', () => {
@@ -54,7 +54,7 @@ test('lax schema converter one-has-many', () => {
 			},
 		},
 	)
-	expect(converter2.convert()).deep.eq(schema1)
+	expect(converter2.convert()).toStrictEqual(schema1)
 })
 
 
@@ -93,7 +93,7 @@ test('lax schema converter many-has-many', () => {
 			},
 		},
 	)
-	expect(converter2.convert()).deep.eq(schema1)
+	expect(converter2.convert()).toStrictEqual(schema1)
 })
 
 
@@ -132,6 +132,6 @@ test('lax schema converter one-has-one', () => {
 			},
 		},
 	)
-	expect(converter2.convert()).deep.eq(schema1)
+	expect(converter2.convert()).toStrictEqual(schema1)
 })
 

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

@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { MembershipResolver, MembershipValidationErrorType } from '../../../src'
 import { Acl } from '@contember/schema'
 
@@ -17,8 +17,8 @@ test('read membership with entity variable', () => {
 	}, [
 		{ role: 'editor', variables: [{ name: 'localeID', values: [id1] }] },
 	], MembershipResolver.UnknownIdentity)
-	assert.lengthOf(result.errors, 0)
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { in: [id1] } }] },
 	])
 })
@@ -37,13 +37,13 @@ test('read fails when variable is not provided', () => {
 	}, [
 		{ role: 'editor', variables: [] },
 	], MembershipResolver.UnknownIdentity)
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_EMPTY,
 		role: 'editor',
 		variable: 'localeID',
 	}])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { never: true } }] },
 	])
 })
@@ -64,8 +64,8 @@ test('read membership with predefined variable', () => {
 	], {
 		identityId: id1,
 	})
-	assert.lengthOf(result.errors, 0)
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'self', condition: { in: [id1] } }] },
 	])
 })
@@ -84,8 +84,8 @@ test('read membership with condition variable', () => {
 	}, [
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify({ eq: 'foo' })] }] },
 	], MembershipResolver.UnknownIdentity)
-	assert.lengthOf(result.errors, 0)
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.errors).toStrictEqual([])
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'cond', condition: { eq: 'foo' } }] },
 	])
 })
@@ -105,13 +105,13 @@ test('fails on invalid condition', () => {
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
 	], MembershipResolver.UnknownIdentity)
 
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_INVALID,
 		role: 'editor',
 		variable: 'cond',
 	}])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'cond', condition: { never: true } }] },
 	])
 })
@@ -127,13 +127,13 @@ test('fails on undefined role', () => {
 		identityId: id1,
 	})
 
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.ROLE_NOT_FOUND,
 		role: 'editor',
 		variable: undefined,
 	}])
 
-	assert.deepStrictEqual(result.memberships, [])
+	expect(result.memberships).toStrictEqual([])
 })
 
 test('fails on undefined variable', () => {
@@ -149,13 +149,13 @@ test('fails on undefined variable', () => {
 		{ role: 'editor', variables: [{ name: 'cond', values: [JSON.stringify('abcd')] }] },
 	], MembershipResolver.UnknownIdentity)
 
-	assert.deepStrictEqual(result.errors, [{
+	expect(result.errors).toEqual([{
 		error: MembershipValidationErrorType.VARIABLE_NOT_FOUND,
 		role: 'editor',
 		variable: 'cond',
 	}])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [] },
 	])
 })
@@ -175,9 +175,9 @@ test('use fallback value', () => {
 	}, [
 		{ role: 'editor', variables: [] },
 	], MembershipResolver.UnknownIdentity)
-	assert.deepStrictEqual(result.errors, [])
+	expect(result.errors).toStrictEqual([])
 
-	assert.deepStrictEqual(result.memberships, [
+	expect(result.memberships).toStrictEqual([
 		{ role: 'editor', variables: [{ name: 'localeID', condition: { always: true } }] },
 	])
 })

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

@@ -0,0 +1,88 @@
+import { expect, describe, test } from 'bun:test'
+import { modelSchema } from '../../../src/type-schema'
+import { Model } from '@contember/schema'
+
+describe('model schema', () => {
+	const validDataTypes = [
+		'integer',
+		'double precision',
+		'character varying(255)',
+		'numeric(10, 2)',
+		'timestamp(3) with time zone',
+		'geometry(Point, 4326)',
+		'character(10)[]',
+		'bit varying(5)',
+		'VARCHAR(255) COLLATE "de_DE"',
+	]
+
+	// Array of invalid PostgreSQL data type examples
+	const invalidDataTypes = [
+		'varchar(255',           // Missing closing parenthesis
+		'character(10))',        // Extra closing parenthesis
+		'numeric(,2)',           // Missing first parameter
+		'geometry(Point,4326))', // Extra closing parenthesis
+		'VARCHAR(255) COLLATE "de_DE" (extra text)', // Extra text outside the valid pattern
+		'VARCHAR(255) COLLATE "de_DE', // Missing closing quote
+	]
+
+	for (const dataType of validDataTypes) {
+		test(`accept valid data type ${dataType}`, () => {
+			const column: Model.AnyColumn = {
+				type: Model.ColumnType.String,
+				columnName: 'column',
+				name: 'column',
+				columnType: dataType,
+				nullable: false,
+			}
+			const model: Model.Schema = {
+				entities: {
+					Test: {
+						tableName: 'test',
+						primary: 'id',
+						primaryColumn: 'id',
+						unique: [],
+						indexes: [],
+						eventLog: { enabled: false },
+						name: 'Test',
+						fields: {
+							column,
+						},
+					},
+				},
+				enums: {},
+			}
+			expect(modelSchema(model)).toStrictEqual(model)
+		})
+	}
+
+	for (const dataType of invalidDataTypes) {
+		test(`reject invalid data type ${dataType}`, () => {
+			const column: Model.AnyColumn = {
+				type: Model.ColumnType.String,
+				columnName: 'column',
+				name: 'column',
+				columnType: dataType,
+				nullable: false,
+			}
+			const model: Model.Schema = {
+				entities: {
+					Test: {
+						tableName: 'test',
+						primary: 'id',
+						primaryColumn: 'id',
+						unique: [],
+						indexes: [],
+						eventLog: { enabled: false },
+						name: 'Test',
+						fields: {
+							column,
+						},
+					},
+				},
+				enums: {},
+			}
+			expect(() => modelSchema(model)).toThrow(`value at path /entities/Test/fields/column: all variants of union has failed:
+            value at path /entities/Test/fields/column/columnType: must be valid column type, "${dataType.replaceAll('"', '\\"')}" given`)
+		})
+	}
+})

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

@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest'
+import { expect, test } from 'bun:test'
 import { Model } from '@contember/schema'
 import { ModelValidator } from '../../../src'
 import { c, createSchema } from '@contember/schema-definition'
@@ -64,7 +64,7 @@ test('"meta" collision', () => {
 		},
 	}
 	const validator = new ModelValidator(model)
-	assert.deepStrictEqual(validator.validate(), [
+	expect(validator.validate()).toStrictEqual([
 		{
 			code: 'MODEL_NAME_COLLISION',
 			message: 'entity FooMeta collides with entity Foo, because a GraphQL type with "Meta" suffix is created for every entity',
@@ -83,7 +83,7 @@ namespace ColumnNameCollision {
 test('column name collision', () => {
 	const schema = createSchema(ColumnNameCollision)
 	const validator = new ModelValidator(schema.model)
-	assert.deepStrictEqual(validator.validate(), [
+	expect(validator.validate()).toStrictEqual([
 		{
 			code: 'MODEL_NAME_COLLISION',
 			message: 'Column name "rel_id" on field "relId" collides with a column name on field "rel".',

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

@@ -1,100 +1,88 @@
-import { beforeAll, describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'bun:test'
 import { printJsValue } from '../../../src/utils/printJsValue'
 
-beforeAll(() => {
-	expect.addSnapshotSerializer({
-		test: val => typeof val === 'string',
-		print: val => String(val),
-	})
-})
-
 describe('printJsValue', () => {
 	test('string', () => {
-		expect(printJsValue('foobar')).toMatchInlineSnapshot(`'foobar'`)
+		expect(printJsValue('foobar')).toEqual(`'foobar'`)
 	})
 
 	test('string escape', () => {
-		expect(printJsValue('foo\'bar')).toMatchInlineSnapshot(`'foo\\'bar'`)
+		expect(printJsValue('foo\'bar')).toEqual(`'foo\\'bar'`)
 	})
 
 	test('number', () => {
-		expect(printJsValue(11)).toMatchInlineSnapshot(`11`)
+		expect(printJsValue(11)).toEqual(`11`)
 	})
 
 	test('boolean', () => {
-		expect(printJsValue(true)).toMatchInlineSnapshot(`true`)
+		expect(printJsValue(true)).toEqual(`true`)
 	})
 
 	test('null', () => {
-		expect(printJsValue(null)).toMatchInlineSnapshot(`null`)
+		expect(printJsValue(null)).toEqual(`null`)
 	})
 
 	test('inline array', () => {
-		expect(printJsValue([1, 2, 3])).toMatchInlineSnapshot(`[1, 2, 3]`)
+		expect(printJsValue([1, 2, 3])).toEqual(`[1, 2, 3]`)
 	})
 	test('block array', () => {
-		expect(printJsValue([1, 2, 3], () => true)).toMatchInlineSnapshot(`
-			[
-				1,
-				2,
-				3,
-			]
-		`)
+		expect(printJsValue([1, 2, 3], () => true)).toEqual(
+			`[
+	1,
+	2,
+	3,
+]`)
 	})
 
 	test('inline object', () => {
-		expect(printJsValue({ a: 1, b: 2 })).toMatchInlineSnapshot('{ a: 1, b: 2 }')
+		expect(printJsValue({ a: 1, b: 2 })).toEqual('{ a: 1, b: 2 }')
 	})
 
 	test('block object', () => {
-		expect(printJsValue({ a: 1, b: 2 }, () => true)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: 2,
-			}
-		`)
+		expect(printJsValue({ a: 1, b: 2 }, () => true)).toEqual(
+			`{
+	a: 1,
+	b: 2,
+}`)
 	})
 
 	test('nested block object', () => {
-		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, () => true)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: {
-					c: {
-						d: {
-							e: 1,
-						},
-					},
-				},
-			}
-		`)
+		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, () => true)).toEqual(
+			`{
+	a: 1,
+	b: {
+		c: {
+			d: {
+				e: 1,
+			},
+		},
+	},
+}`)
 	})
 
 
 	test('one level nested block object', () => {
-		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: { c: { d: { e: 1 } } },
-			}
-		`)
+		expect(printJsValue({ a: 1, b: { c: { d: { e: 1 } } } }, (_, path) => path.length === 0)).toEqual(
+			`{
+	a: 1,
+	b: { c: { d: { e: 1 } } },
+}`)
 	})
 
 	test('nested block object and arr', () => {
-		expect(printJsValue({ a: 1, b: [2, { c: 4 }, [5, 6]] }, () => true)).toMatchInlineSnapshot(`
-			{
-				a: 1,
-				b: [
-					2,
-					{
-						c: 4,
-					},
-					[
-						5,
-						6,
-					],
-				],
-			}
-		`)
+		expect(printJsValue({ a: 1, b: [2, { c: 4 }, [5, 6]] }, () => true)).toEqual(
+			`{
+	a: 1,
+	b: [
+		2,
+		{
+			c: 4,
+		},
+		[
+			5,
+			6,
+		],
+	],
+}`)
 	})
 })

package/tests/cases/unit/schemas/acl.ts

@@ -1,32 +1,30 @@
 import { c } from '@contember/schema-definition'
 
-export const readerRole = c.createRole('reader', { stages: '*' })
-
 export const editorRole = c.createRole('editor', { stages: '*' })
 
-export const categoryEditorVariable = c.createEntityVariable('category', 'Category', editorRole)
+export const readerRole = c.createRole('reader', { stages: '*' })
 
+export const categoryEditorVariable = c.createEntityVariable('category', 'Category', editorRole)
 
-@c.Allow(readerRole, {
-	read: true,
-})
 @c.Allow(editorRole, {
 	when: { category: { id: categoryEditorVariable } },
 	read: true,
 	create: ['title', 'category'],
 	update: ['title', 'category'],
 })
+@c.Allow(readerRole, {
+	read: true,
+})
 export class Article {
 	title = c.stringColumn()
 	deletedAt = c.dateTimeColumn()
 	category = c.manyHasOne(Category)
 }
 
-
-@c.Allow(readerRole, {
+@c.Allow(editorRole, {
 	read: true,
 })
-@c.Allow(editorRole, {
+@c.Allow(readerRole, {
 	read: true,
 })
 export class Category {

package/tests/cases/unit/schemas/complex.ts

@@ -0,0 +1,38 @@
+import { c } from '@contember/schema-definition'
+
+export const editorRole = c.createRole('editor', { stages: '*' })
+
+export const readerRole = c.createRole('reader', { stages: '*' })
+
+export const categoryEditorVariable = c.createEntityVariable('category', 'Category', editorRole)
+
+@c.Unique('title')
+@c.View(`SELECT * FROM article`)
+@c.Allow(editorRole, {
+	when: { category: { id: categoryEditorVariable } },
+	read: true,
+	create: ['title', 'category'],
+	update: ['title', 'category'],
+})
+@c.Allow(readerRole, {
+	read: true,
+})
+export class Article {
+	title = c.stringColumn()
+	deletedAt = c.dateTimeColumn()
+	category = c.manyHasOne(Category)
+}
+
+@c.View(`
+SELECT * FROM article
+
+`)
+@c.Allow(editorRole, {
+	read: true,
+})
+@c.Allow(readerRole, {
+	read: true,
+})
+export class Category {
+	name = c.stringColumn()
+}

package/tests/cases/unit/schemas/view.ts

@@ -0,0 +1,6 @@
+import { c } from '@contember/schema-definition'
+
+@c.View(`SELECT * FROM article`)
+export class Article {
+	title = c.stringColumn()
+}

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

@@ -1,10 +1,12 @@
 import { createSchema } from '@contember/schema-definition'
-import { expect, test } from 'vitest'
+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 { readFile, writeFile } from 'fs/promises'
 import { join } from 'path'
 import { DefinitionCodeGenerator } from '../../../src/definition-generator/DefinitionCodeGenerator'
@@ -13,10 +15,12 @@ import { fileURLToPath } from 'node:url'
 
 const tests = [
 	['basic', basic],
+	['complex', complex],
 	['relations', relations],
 	['unique', unique],
 	['enum', enum_],
 	['acl', acl],
+	['view', view],
 ] as const
 for (const [name, def] of tests) {
 	test(`generate schema: ${name}`, async () => {