@contember/schema-utils 1.2.1 → 1.3.0-alpha.4

package/src/type-schema/model.ts

@@ -169,6 +169,7 @@ const entitySchema = Typesafe.intersection(
 	}),
 	Typesafe.partial({
 		view: viewSchema,
+		orderBy: orderBySchema,
 	}),
 )
 

package/src/type-schema/where.ts

@@ -0,0 +1,28 @@
+import { Input, Model } from '@contember/schema'
+import { acceptFieldVisitor } from '../model'
+import { conditionSchema } from './condition'
+import * as Typesafe from '@contember/typesafe'
+
+export const whereSchema = ({ schema, entity }: {
+	schema: Model.Schema
+	entity: Model.Entity
+}): Typesafe.Type<Input.Where> => {
+	return (input: unknown, path: PropertyKey[] = []): Input.Where => {
+		const whereSchemaInner = Typesafe.noExtraProps(Typesafe.partial({
+			and: Typesafe.array(whereSchema({ schema, entity })),
+			or: Typesafe.array(whereSchema({ schema, entity })),
+			not: whereSchema({ schema, entity }),
+			...Object.fromEntries(Object.values(entity.fields).map((it): [string, Typesafe.Type<Input.Where[any]>] => {
+				return [
+					it.name,
+					acceptFieldVisitor(schema, entity, it.name, {
+						visitColumn: ({ column }) => conditionSchema(column.type),
+						visitRelation: ({ targetEntity }) => whereSchema({ schema, entity: targetEntity }),
+					}),
+				]
+			})),
+		}))
+
+		return whereSchemaInner(input, path)
+	}
+}

package/src/validation/ActionsValidator.ts

@@ -0,0 +1,119 @@
+import { Actions, Model } from '@contember/schema'
+import { acceptFieldVisitor } from '../model'
+import { ErrorBuilder, ValidationError } from './errors'
+import { assertNever } from '../utils'
+import * as Typesafe from '@contember/typesafe'
+import { whereSchema } from '../type-schema/where'
+
+const manyArgsSchema = (args: {schema: Model.Schema; entity: Model.Entity}) => Typesafe.partial({
+	limit: Typesafe.integer,
+	offset: Typesafe.integer,
+	orderBy: Typesafe.array(Typesafe.anyJsonObject),
+	filter: whereSchema(args),
+})
+
+export class ActionsValidator {
+	constructor(private readonly model: Model.Schema) {}
+
+	public validate(schema: Actions.Schema): ValidationError[] {
+		const errorBuilder = new ErrorBuilder([], ['actions'])
+		this.validateTriggers(schema, errorBuilder.for('triggers'))
+		return errorBuilder.errors
+	}
+
+	private validateTriggers(schema: Actions.Schema, errorBuilder: ErrorBuilder) {
+		for (const [name, def] of Object.entries(schema.triggers)) {
+			const triggerErrorBuilder = errorBuilder.for(name)
+			if (name !== def.name) {
+				triggerErrorBuilder.add('ACTIONS_NAME_MISMATCH', `Trigger name ${def.name} does not match the name in a map ${name}`)
+			}
+			if (!schema.targets[def.target]) {
+				triggerErrorBuilder.add('ACTIONS_UNDEFINED_TRIGGER_TARGET', `Trigger target ${def.target} not found`)
+			}
+			this.validateTrigger(def, triggerErrorBuilder)
+		}
+	}
+
+
+	private validateTrigger(trigger: Actions.AnyTrigger, errorBuilder: ErrorBuilder): void {
+		const entity = this.model.entities[trigger.entity]
+		if (!entity) {
+			errorBuilder.add('ACTIONS_UNDEFINED_ENTITY', `Entity ${trigger.entity} not found.`)
+			return
+		}
+
+		switch (trigger.type) {
+			case 'watch':
+				this.validateWatchTrigger(trigger, entity, errorBuilder)
+				break
+			case 'basic':
+				this.validateBasicTrigger(trigger, entity, errorBuilder)
+				break
+			default:
+				assertNever(trigger)
+		}
+	}
+
+	private validateWatchTrigger(trigger: Actions.WatchTrigger, entity: Model.Entity, errorBuilder: ErrorBuilder): void {
+		this.validateSelection(trigger.watch, entity, errorBuilder.for('watch'))
+		if (trigger.selection) {
+			this.validateSelection(trigger.selection, entity, errorBuilder.for('selection'))
+		}
+	}
+
+	private validateBasicTrigger(trigger: Actions.BasicTrigger, entity: Model.Entity, errorBuilder: ErrorBuilder): void {
+		if (trigger.selection) {
+			this.validateSelection(trigger.selection, entity, errorBuilder.for('selection'))
+		}
+
+		if (Array.isArray(trigger.update)) {
+			for (const field of trigger.update) {
+				if (!entity.fields[field]) {
+					errorBuilder.for('update').add('ACTIONS_UNDEFINED_FIELD', `Field ${field} of entity ${entity.name} not found.`)
+				}
+			}
+		}
+	}
+
+	private validateSelection(
+		selectionNode: Actions.SelectionNode,
+		entity: Model.Entity,
+		errorBuilder: ErrorBuilder,
+	): void {
+		for (const part of selectionNode) {
+			const [field, args, selection] = Array.isArray(part) ? part : [part, {}, []]
+			const fieldErrorBuilder = errorBuilder.for(field)
+			if (!entity.fields[field]) {
+				fieldErrorBuilder.add('ACTIONS_UNDEFINED_FIELD', `Undefined field ${field} on entity ${entity.name}`)
+				continue
+			}
+			acceptFieldVisitor(this.model, entity, field, {
+				visitColumn: () => {
+					if (selection.length) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Unexpected sub selection on a column.`)
+					}
+					if (Object.keys(args).length !== 0) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Unexpected args on a column.`)
+					}
+				},
+				visitHasMany: ({ targetEntity }) => {
+					if (selection.length === 0) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Sub-selection expected on a relation.`)
+					}
+					this.validateSelection(selection, targetEntity, fieldErrorBuilder)
+					try {
+						manyArgsSchema({ schema: this.model, entity: targetEntity })(args)
+					} catch (e: any) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Selection args are not valid: ` + e.message)
+					}
+				},
+				visitHasOne: ({ targetEntity }) => {
+					if (selection.length === 0) {
+						fieldErrorBuilder.add('ACTIONS_INVALID_SELECTION', `Sub-selection expected on a relation.`)
+					}
+					this.validateSelection(selection, targetEntity, fieldErrorBuilder)
+				},
+			})
+		}
+	}
+}

package/src/validation/ModelValidator.ts

@@ -94,7 +94,7 @@ export class ModelValidator {
 					const orderByField = entity.fields[it.path[i]]
 					const pathStr = it.path.slice(0, i + 1).join('.')
 					if (!orderByField) {
-						errors.add('ACL_UNDEFINED_FIELD', `Invalid orderBy of ${entityName}::${field.name}: field ${pathStr} is not defined`)
+						errors.add('MODEL_UNDEFINED_FIELD', `Invalid orderBy of ${entityName}::${field.name}: field ${pathStr} is not defined`)
 						return
 					}
 					if (i + 1 < it.path.length) {

package/src/validation/SchemaValidator.ts

@@ -3,6 +3,7 @@ import { ValidationError, ValidationErrorCode } from './errors'
 import { AclValidator } from './AclValidator'
 import { ModelValidator } from './ModelValidator'
 import { ValidationValidator } from './ValidationValidator'
+import { ActionsValidator } from './ActionsValidator'
 
 export interface SchemaValidatorSkippedErrors {
 	code: ValidationErrorCode
@@ -20,7 +21,11 @@ export class SchemaValidator {
 
 		const validationValidator = new ValidationValidator(schema.model)
 		const validationErrors = validationValidator.validate(schema.validation)
-		const allErrors = [...aclErrors, ...modelErrors, ...validationErrors]
+
+		const actionsValidator = new ActionsValidator(schema.model)
+		const actionsErrors  = actionsValidator.validate(schema.actions)
+
+		const allErrors = [...aclErrors, ...modelErrors, ...validationErrors, ...actionsErrors]
 		if (skippedErrors.length === 0) {
 			return allErrors
 		}

package/src/validation/errors.ts

@@ -16,6 +16,13 @@ export type ValidationErrorCode =
 	| 'ACL_UNDEFINED_ROLE'
 	| 'ACL_UNDEFINED_ENTITY'
 
+	| 'ACTIONS_NAME_MISMATCH'
+	| 'ACTIONS_INVALID_CONDITION'
+	| 'ACTIONS_UNDEFINED_FIELD'
+	| 'ACTIONS_UNDEFINED_ENTITY'
+	| 'ACTIONS_UNDEFINED_TRIGGER_TARGET'
+	| 'ACTIONS_INVALID_SELECTION'
+
 	| 'VALIDATION_UNDEFINED_ENTITY'
 	| 'VALIDATION_UNDEFINED_FIELD'
 	| 'VALIDATION_NOT_IMPLEMENTED'

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

@@ -5,6 +5,10 @@ exports[`lax schema converter basic 1`] = `
   "acl": {
     "roles": {},
   },
+  "actions": {
+    "targets": {},
+    "triggers": {},
+  },
   "model": {
     "entities": {
       "Article": {
@@ -67,6 +71,10 @@ exports[`lax schema converter many-has-many 1`] = `
   "acl": {
     "roles": {},
   },
+  "actions": {
+    "targets": {},
+    "triggers": {},
+  },
   "model": {
     "entities": {
       "Article": {
@@ -155,6 +163,10 @@ exports[`lax schema converter one-has-many 1`] = `
   "acl": {
     "roles": {},
   },
+  "actions": {
+    "targets": {},
+    "triggers": {},
+  },
   "model": {
     "entities": {
       "Article": {
@@ -234,6 +246,10 @@ exports[`lax schema converter one-has-one 1`] = `
   "acl": {
     "roles": {},
   },
+  "actions": {
+    "targets": {},
+    "triggers": {},
+  },
   "model": {
     "entities": {
       "Article": {

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

@@ -0,0 +1,89 @@
+import { assert, test, describe } from 'vitest'
+import { conditionSchema } from '../../../src/type-schema'
+import { Model } from '@contember/schema'
+import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
+import { whereSchema } from '../../../src/type-schema/where'
+
+namespace MyModel {
+	export class Article {
+		title = def.stringColumn()
+		category = def.manyHasOne(Category)
+		tags = def.manyHasMany(Tag)
+	}
+
+	export class Category {
+		name = def.stringColumn()
+	}
+
+	export class Tag {
+		name = def.stringColumn()
+	}
+}
+
+const schema = createSchema(MyModel).model
+
+describe('where schema', () => {
+	test('simple scalar where', () => {
+		const where = {
+			title: { eq: 'foo' },
+		}
+		assert.deepStrictEqual(whereSchema({ schema, entity: schema.entities.Article })(where), where)
+	})
+
+	test('where with and / or /not', () => {
+		const where = {
+			and: [
+				{
+					or: [
+						{ not: { title: { eq: 'bar' } } },
+					],
+				},
+			],
+		}
+		assert.deepStrictEqual(whereSchema({ schema, entity: schema.entities.Article })(where), where)
+	})
+
+
+	test('where with relation', () => {
+		const where = {
+			tags: { name: { eq: 'xx' } },
+		}
+		assert.deepStrictEqual(whereSchema({ schema, entity: schema.entities.Article })(where), where)
+	})
+
+	test('undefined field', () => {
+		const where = {
+			name: { eq: 'foo' },
+		}
+		assert.throw(() => whereSchema({
+			schema,
+			entity: schema.entities.Article,
+		})(where), 'value at root: extra property name found')
+	})
+
+
+	test('undefined field in relation', () => {
+		const where = {
+			tags: {
+				caption: { eq: 'foo' },
+
+			},
+		}
+		assert.throw(() => whereSchema({
+			schema,
+			entity: schema.entities.Article,
+		})(where), 'value at path /tags: extra property caption found')
+	})
+
+
+	test('invalid condition', () => {
+		const where = {
+			title: { xx: 'foo' },
+		}
+		assert.throw(() => whereSchema({
+			schema,
+			entity: schema.entities.Article,
+		})(where), 'value at path /title: extra property xx found')
+	})
+
+})

package/tests/tsconfig.json

@@ -5,8 +5,6 @@
 		"esModuleInterop": true
 	},
 	"references": [
-		{
-			"path": "../src"
-		}
+		{ "path": "../src" }
 	]
 }

package/tsconfig.json

@@ -2,11 +2,7 @@
 	"files": [],
 	"include": [],
 	"references": [
-		{
-			"path": "./src"
-		},
-		{
-			"path": "./tests"
-		}
+		{ "path": "./src" },
+		{ "path": "./tests" }
 	]
 }