@contember/schema-definition 1.2.1 → 1.3.0-alpha.13

package/src/actions/definition/internal/ActionsFactory.ts

@@ -0,0 +1,190 @@
+import { assertNever, filterEntityDefinition } from '../../../utils'
+import { Actions } from '@contember/schema'
+import { triggersStore } from './store'
+import { BasicTriggerDefinition, TargetDefinition, WatchTriggerDefinition } from '../triggers'
+import { ActionsTarget } from '../targets'
+import { Kind, parse, SelectionNode, ValueNode } from 'graphql'
+
+export class ActionsFactory {
+	constructor(
+	) {
+	}
+
+	public create(
+		exportedDefinitions: Record<string, any>,
+	): Actions.Schema {
+		const entityLikeDefinition = filterEntityDefinition(exportedDefinitions)
+
+		const targetsRegistry = new ActionsTargetRegistry()
+		for (const [exportedAs, def] of Object.entries(exportedDefinitions)) {
+			if (!(def instanceof ActionsTarget)) {
+				continue
+			}
+			const name = def.name ?? exportedAs
+			targetsRegistry.register(name, def.definition)
+		}
+
+		const triggersDef = entityLikeDefinition.flatMap(([, entity]) => triggersStore.get(entity).map(it => ({
+			...it,
+			entity,
+		})))
+
+		const triggerNames = triggersDef.map(it => it.definition.name).filter((it): it is string => !!it)
+		triggerNames.forEach((it, index, arr) => {
+			if (arr.indexOf(it) !== index) {
+				throw `Duplicate trigger name ${it}.`
+			}
+		})
+
+		const triggers: Record<string, Actions.AnyTrigger> = {}
+		for (const { definition, entity, type } of triggersDef) {
+			const name = definition.name
+			const target = this.resolveTarget(name, definition, targetsRegistry)
+			let trigger: Actions.AnyTrigger
+			if (type === 'basic') {
+				trigger = {
+					target,
+					...this.createBasicTrigger(name, entity.name, definition),
+				}
+			} else if (type === 'watch') {
+				trigger = {
+					target,
+					...this.createWatchTrigger(name, entity.name, definition),
+				}
+			} else {
+				assertNever(type)
+			}
+			triggers[name] = trigger
+		}
+
+
+		return { triggers, targets: targetsRegistry.getTargets() }
+	}
+
+	private resolveTarget(triggerName: string, targetDefinition: TargetDefinition, targetRegistry: ActionsTargetRegistry): string {
+		const generatedName = `${triggerName}_target`
+		if ('target' in targetDefinition) {
+			if (targetDefinition.target instanceof ActionsTarget) {
+				const registeredName = targetRegistry.getName(targetDefinition.target.definition)
+				if (!registeredName) {
+					throw `Target of ${triggerName} trigger is not registered. Have you exported it?`
+				}
+				return registeredName
+			} else {
+				const { name, ...def } = targetDefinition.target
+				const resolvedName = name ?? generatedName
+				targetRegistry.register(resolvedName, { name: generatedName, ...def })
+				return resolvedName
+			}
+		} else if ('webhook' in targetDefinition) {
+			if (typeof targetDefinition.webhook === 'string') {
+				targetRegistry.register(generatedName, {
+					name: generatedName,
+					type: 'webhook',
+					url: targetDefinition.webhook,
+				})
+			} else {
+				targetRegistry.register(generatedName, {
+					type: 'webhook',
+					...targetDefinition.webhook,
+				})
+			}
+			return generatedName
+		}
+		return assertNever(targetDefinition)
+	}
+
+	private createWatchTrigger(name: string, entity: string, trigger: WatchTriggerDefinition): Omit<Actions.WatchTrigger, 'target'> {
+		return {
+			type: 'watch',
+			entity,
+			name,
+			watch: this.parseSelection(trigger.watch),
+			selection: trigger.selection ? this.parseSelection(trigger.selection) : undefined,
+		}
+	}
+
+	private createBasicTrigger(name: string, entity: string, trigger: BasicTriggerDefinition): Omit<Actions.BasicTrigger, 'target'> {
+		return {
+			type: 'basic',
+			entity,
+			name,
+			create: trigger.create ?? false,
+			delete: trigger.delete ?? false,
+			update: trigger.update ?? false,
+			selection: trigger.selection ? this.parseSelection(trigger.selection) : undefined,
+		}
+	}
+
+	private parseSelection(selection: Actions.SelectionNode | string): Actions.SelectionNode {
+		if (typeof selection !== 'string') {
+			return selection
+		}
+		const result = parse(`{
+			${selection}
+		}`)
+		for (const def of result.definitions) {
+			if (def.kind === 'OperationDefinition') {
+				return this.processSelectionSet(def.selectionSet.selections)
+			}
+		}
+		throw new Error()
+	}
+
+	private processSelectionSet(selectionSet: readonly SelectionNode[]): Actions.SelectionNode {
+		return selectionSet.map(it => {
+			if (it.kind !== 'Field') {
+				throw `${it.kind} is not supported.`
+			}
+			if (it.arguments?.length === 0 && it.selectionSet === undefined) {
+				return it.name.value
+			}
+			const args = Object.fromEntries(it.arguments?.map(it => [it.name, parseArguments(it.value)]) ?? [])
+			return [it.name.value, args, it.selectionSet ? this.processSelectionSet(it.selectionSet.selections) : []]
+		})
+	}
+}
+
+class ActionsTargetRegistry {
+	private targets: Record<string, Actions.AnyTarget> = {}
+	private targetsInverseMap = new Map<Omit<Actions.AnyTarget, 'name'>, string>()
+
+	public register(name: string, target: Omit<Actions.AnyTarget, 'name'> & { name?: string }): void {
+		if (this.targets[name]) {
+			throw `Duplicate trigger target name ${name}`
+		}
+		this.targets[name] = { name, ...target }
+		this.targetsInverseMap.set(target, name)
+	}
+
+	public getName(target: Omit<Actions.AnyTarget, 'name'>): string | undefined {
+		return this.targetsInverseMap.get(target)
+	}
+
+	public getTargets() {
+		return this.targets
+	}
+}
+
+const parseArguments = (ast: ValueNode): any => {
+	switch (ast.kind) {
+		case Kind.STRING:
+			return ast.value
+		case Kind.BOOLEAN:
+			return ast.value
+		case Kind.FLOAT:
+			return parseFloat(ast.value)
+		case Kind.INT:
+			return Number(ast.value)
+		case Kind.LIST:
+			return ast.values.map(it => parseArguments(it))
+		case Kind.OBJECT:
+			return Object.fromEntries(ast.fields.map(it => [it.name.value, parseArguments(it.value)]))
+		case Kind.ENUM:
+			return ast.value
+		case Kind.NULL:
+			return null
+		case Kind.VARIABLE:
+			throw `Variables are not supported here.`
+	}
+}

package/src/actions/definition/internal/store.ts

@@ -0,0 +1,8 @@
+import { createMetadataStore } from '../../../utils'
+import { BasicTriggerDefinition, WatchTriggerDefinition } from '../triggers'
+
+type StoredTrigger =
+	| { type: 'basic'; definition: BasicTriggerDefinition }
+	| { type: 'watch'; definition: WatchTriggerDefinition }
+
+export const triggersStore = createMetadataStore<StoredTrigger[]>([])

package/src/actions/definition/targets.ts

@@ -0,0 +1,15 @@
+import { Actions } from '@contember/schema'
+
+
+export class ActionsTarget {
+	constructor(
+		public readonly name: string | undefined,
+		public readonly definition: Omit<Actions.AnyTarget, 'name'>,
+	) {
+	}
+}
+
+export const createTarget = ({
+	name,
+	...definition
+}: Actions.AnyTarget & { name?: string }) => new ActionsTarget(name, definition)

package/src/actions/definition/triggers.ts

@@ -0,0 +1,45 @@
+import { DecoratorFunction, EntityConstructor } from '../../utils'
+import { Actions } from '@contember/schema'
+import { triggersStore } from './internal/store'
+import { ActionsTarget } from './targets'
+
+export type TriggerWebhookDefinition = {
+	webhook:
+		| string
+		| Omit<Actions.WebhookTarget, 'type'>
+}
+
+export type TriggerTargetDefinition = {
+	target: (Omit<Actions.AnyTarget, 'name'> & { name?: string }) | ActionsTarget
+}
+
+export type TargetDefinition =
+	| TriggerWebhookDefinition
+	| TriggerTargetDefinition
+
+export type BasicTriggerDefinition =
+	& {
+		readonly name: string
+		readonly create?: boolean
+		readonly delete?: boolean
+		readonly update?: boolean | readonly string[]
+		readonly selection?: Actions.SelectionNode | string
+	}
+	& TargetDefinition
+
+export type WatchTriggerDefinition =
+	& {
+		readonly name: string
+		readonly watch: Actions.SelectionNode | string
+		readonly selection?: Actions.SelectionNode | string
+	}
+	& TargetDefinition
+
+export const trigger = <T>(definition: BasicTriggerDefinition): DecoratorFunction<T> => (entity: EntityConstructor<T>) => {
+	triggersStore.update(entity, it => [...it, { type: 'basic', definition }])
+}
+
+export const watch = <T>(definition: WatchTriggerDefinition): DecoratorFunction<T> => (entity: EntityConstructor<T>) => {
+	triggersStore.update(entity, it => [...it, { type: 'watch', definition }])
+}
+

package/src/createSchema.ts

@@ -1,6 +1,7 @@
 import { SchemaDefinition } from './model'
 import * as InputValidation from './validation'
 import * as AclDefinition from './acl/definition'
+import * as ActionsDefinition from './actions/definition'
 import { Schema } from '@contember/schema'
 import { emptySchema } from '@contember/schema-utils'
 
@@ -8,6 +9,7 @@ export const createSchema = (definitions: Record<string, any>, modifyCallback?:
 	const model = SchemaDefinition.createModel(definitions)
 	const validation = InputValidation.parseDefinition(definitions)
 	const acl = AclDefinition.createAcl(definitions, model)
-	const schema = { ...emptySchema, model, validation, acl }
+	const actions = ActionsDefinition.createActions(definitions)
+	const schema = { ...emptySchema, model, validation, acl, actions }
 	return modifyCallback ? modifyCallback(schema) : schema
 }

package/src/index.ts

@@ -2,5 +2,6 @@ export { AllowAllPermissionFactory } from '@contember/schema-utils'
 export { PermissionsBuilder } from './acl/builder/PermissionsBuilder'
 export * as InputValidation from './validation'
 export * as AclDefinition from './acl/definition'
+export * as ActionsDefinition from './actions/definition'
 export * from './createSchema'
 export * from './model'

package/src/model/builder/EntityBuilder.ts

@@ -89,6 +89,16 @@ class EntityBuilder {
 	getFields(): FieldBuilder.Map {
 		return this.fields
 	}
+
+	orderBy(field: string | string[], direction: Model.OrderDirection = Model.OrderDirection.asc): EntityBuilder {
+		const path = typeof field === 'string' ? [field] : field
+
+		return new EntityBuilder(
+			{ ...this.options, orderBy: [...(this.options.orderBy ?? []), { path, direction }] },
+			this.fields,
+			this.addEntity,
+		)
+	}
 }
 
 namespace EntityBuilder {
@@ -102,6 +112,7 @@ namespace EntityBuilder {
 	export type EntityOptions = {
 		primary?: string
 		tableName?: string
+		orderBy?: Model.OrderBy[]
 		unique?: UniqueOptions[]
 	}
 }

package/src/model/builder/SchemaBuilderInternal.ts

@@ -1,5 +1,5 @@
-import { Model, Writable } from '@contember/schema'
-import { NamingHelper } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+import { NamingConventions } from '@contember/schema-utils'
 import EntityBuilder from './EntityBuilder'
 import { SchemaBuilderError } from './SchemaBuilderError'
 import FieldProcessor from './internal/FieldProcessor'
@@ -8,7 +8,6 @@ import ManyHasManyProcessor from './internal/ManyHasManyProcessor'
 import OneHasOneProcessor from './internal/OneHasOneProcessor'
 import OneHasManyProcessor from './internal/OneHasManyProcessor'
 import ManyHasOneProcessor from './internal/ManyHasOneProcessor'
-import { NamingConventions } from '@contember/schema-utils'
 import FieldBuilder from './FieldBuilder'
 
 export default class SchemaBuilderInternal {
@@ -39,11 +38,12 @@ export default class SchemaBuilderInternal {
 			primaryColumn: primaryField.options.columnName || this.conventions.getColumnName(primaryName),
 			unique: this.createUnique(name, options, fieldOptions),
 			fields: {},
-			indexes: {},
+			indexes: [],
 			tableName: options.tableName || this.conventions.getTableName(name),
 			eventLog: {
 				enabled: true,
 			},
+			...(options.orderBy !== undefined ? { orderBy: options.orderBy } : {}),
 		}
 	}
 
@@ -159,17 +159,16 @@ export default class SchemaBuilderInternal {
 		options: EntityBuilder.EntityOptions,
 		fieldOptions: FieldBuilder.Map,
 	): Model.UniqueConstraints {
-		const unique: Writable<Model.UniqueConstraints> = {}
+		const unique: Model.UniqueConstraint[] = []
+
 		for (const singleUnique of options.unique || []) {
-			const name = singleUnique.name || NamingHelper.createUniqueConstraintName(entityName, singleUnique.fields)
-			unique[name] = { fields: singleUnique.fields, name: name }
+			unique.push(singleUnique)
 		}
 		for (let fieldName in fieldOptions) {
 			const options = fieldOptions[fieldName]
 
 			if (options.type === FieldBuilder.Type.Column && options.options.unique) {
-				const uniqueName = NamingHelper.createUniqueConstraintName(entityName, [fieldName])
-				unique[uniqueName] = { fields: [fieldName], name: uniqueName }
+				unique.push({ fields: [fieldName] })
 			}
 		}
 		return unique

package/src/model/definition/IndexDefinition.ts

@@ -1,23 +1,18 @@
-import { DecoratorFunction } from './types'
 import { extendEntity } from './extensions'
-import { NamingHelper } from '@contember/schema-utils'
+import { DecoratorFunction } from '../../utils'
 
-export type IndexOptions<T> = { name?: string; fields: (keyof T)[] }
+export type IndexOptions<T> = { fields: (keyof T)[] }
 export function Index<T>(options: IndexOptions<T>): DecoratorFunction<T>
 export function Index<T>(...fields: (keyof T)[]): DecoratorFunction<T>
 export function Index<T>(options: IndexOptions<T> | keyof T, ...args: (keyof T)[]): DecoratorFunction<T> {
 	return extendEntity(({ entity }) => {
 		const fields = (typeof options !== 'object' ? [options, ...args] : options.fields) as string[]
-		const name =
-			typeof options === 'object' && options.name
-				? options.name
-				: NamingHelper.createIndexName(entity.name, fields)
 		return {
 			...entity,
-			indexes: {
+			indexes: [
 				...entity.indexes,
-				[name]: { name, fields },
-			},
+				{ fields },
+			],
 		}
 	})
 }

package/src/model/definition/OrderByDefinition.ts

@@ -0,0 +1,24 @@
+import { Model } from '@contember/schema'
+import { extendEntity } from './extensions'
+import { DecoratorFunction } from '../../utils'
+
+
+export type OrderByOptions = { path: string[]; direction?: Model.OrderDirection }
+
+export function OrderBy<T>(options: OrderByOptions): DecoratorFunction<T>
+export function OrderBy<T>(path: (keyof T), direction?: Model.OrderDirection): DecoratorFunction<T>
+export function OrderBy<T>(options: OrderByOptions | keyof T, direction?: Model.OrderDirection): DecoratorFunction<T> {
+	return extendEntity(({ entity }) => {
+		const path = (typeof options !== 'object' ? [options] : options.path) as string[]
+		const dir =
+			((typeof options === 'object' && options.direction)
+				? options.direction
+				: direction) ?? Model.OrderDirection.asc
+
+
+		return {
+			...entity,
+			orderBy: [...(entity.orderBy ?? []), { path, direction: dir }],
+		}
+	})
+}

package/src/model/definition/UniqueDefinition.ts

@@ -1,23 +1,18 @@
-import { DecoratorFunction } from './types'
 import { extendEntity } from './extensions'
-import { NamingHelper } from '@contember/schema-utils'
+import { DecoratorFunction } from '../../utils'
 
-export type UniqueOptions<T> = { name?: string; fields: (keyof T)[] }
+export type UniqueOptions<T> = { fields: (keyof T)[] }
 export function Unique<T>(options: UniqueOptions<T>): DecoratorFunction<T>
 export function Unique<T>(...fields: (keyof T)[]): DecoratorFunction<T>
 export function Unique<T>(options: UniqueOptions<T> | keyof T, ...args: (keyof T)[]): DecoratorFunction<T> {
 	return extendEntity(({ entity }) => {
 		const fields = (typeof options !== 'object' ? [options, ...args] : options.fields) as string[]
-		const name =
-			typeof options === 'object' && options.name
-				? options.name
-				: NamingHelper.createUniqueConstraintName(entity.name, fields)
 		return {
 			...entity,
-			unique: {
+			unique: [
 				...entity.unique,
-				[name]: { name, fields },
-			},
+				{  fields },
+			],
 		}
 	})
 }

package/src/model/definition/extensions.ts

@@ -1,7 +1,8 @@
 import { Model } from '@contember/schema'
-import { DecoratorFunction, EntityConstructor, FieldsDefinition } from './types'
+import { EntityConstructor, FieldsDefinition } from './types'
 import { EntityRegistry, EnumRegistry } from './internal'
 import { NamingConventions } from '@contember/schema-utils'
+import { createMetadataStore, DecoratorFunction } from '../../utils'
 
 interface EntityExtensionArgs {
 	entity: Model.Entity
@@ -14,11 +15,12 @@ interface EntityExtensionArgs {
 	registry: EntityRegistry
 }
 
+const entityExtensionsStore = createMetadataStore<EntityExtension[]>([])
+
 export type EntityExtension = (args: EntityExtensionArgs) => Model.Entity
 export const extendEntity = <T>(extension: EntityExtension): DecoratorFunction<T> => {
 	return function (cls: EntityConstructor) {
-		const extensions = Reflect.getMetadata('extensions', cls) || []
-		Reflect.defineMetadata('extensions', [...extensions, extension], cls)
+		entityExtensionsStore.update(cls, current => [...current, extension])
 	}
 }
 
@@ -26,7 +28,7 @@ export const applyEntityExtensions = (
 	cls: EntityConstructor,
 	args: EntityExtensionArgs,
 ): Model.Entity =>
-	((Reflect.getMetadata('extensions', cls) || []) as EntityExtension[]).reduce(
+	entityExtensionsStore.get(cls).reduce(
 		(entity, ext) => ext({ ...args, entity }),
 		args.entity,
 	)

package/src/model/definition/index.ts

@@ -1,4 +1,4 @@
-import { EntityConstructor, Interface } from './types'
+import { Interface } from './types'
 import { Model } from '@contember/schema'
 import { EnumDefinition } from './EnumDefinition'
 import { SchemaBuilder } from './internal'
@@ -10,6 +10,7 @@ import { DefaultNamingConventions } from '@contember/schema-utils'
 export * from './fieldDefinitions'
 export * from './EventLogDefinition'
 export * from './IndexDefinition'
+export * from './OrderByDefinition'
 export * from './EnumDefinition'
 export * from './UniqueDefinition'
 export * from './ViewDefinition'

package/src/model/definition/internal/EntityRegistry.ts

@@ -1,4 +1,4 @@
-import { EntityConstructor } from '../types'
+import { EntityConstructor } from '../../../utils'
 
 export class EntityRegistry {
 	public readonly entities: Record<string, EntityConstructor> = {}

package/src/model/definition/internal/SchemaBuilder.ts

@@ -1,5 +1,5 @@
-import { Model, Writable } from '@contember/schema'
-import { NamingConventions, NamingHelper } from '@contember/schema-utils'
+import { Model } from '@contember/schema'
+import { NamingConventions } from '@contember/schema-utils'
 import 'reflect-metadata'
 import { tuple } from '../../../utils'
 import { EntityConstructor, FieldsDefinition } from '../types'
@@ -35,7 +35,7 @@ export class SchemaBuilder {
 				primary: primaryName,
 				primaryColumn: this.conventions.getColumnName(primaryName),
 				unique: this.createUnique(entityName, definitionInstance),
-				indexes: {},
+				indexes: [],
 				fields: [
 					...definitionInstance[primaryName] ? [] : [tuple(primaryName, this.createPrimaryColumn())],
 					...Object.entries(definitionInstance),
@@ -84,11 +84,10 @@ export class SchemaBuilder {
 	}
 
 	private createUnique(entityName: string, fieldDefinitions: FieldsDefinition): Model.UniqueConstraints {
-		const unique: Writable<Model.UniqueConstraints> = {}
+		const unique: Model.UniqueConstraint[] = []
 		for (const [fieldName, definition] of Object.entries(fieldDefinitions)) {
 			if (definition.options.unique) {
-				const uniqueName = NamingHelper.createUniqueConstraintName(entityName, [fieldName])
-				unique[uniqueName] = { fields: [fieldName], name: uniqueName }
+				unique.push({ fields: [fieldName] })
 			}
 		}
 		return unique

package/src/model/definition/types.ts

@@ -1,7 +1,7 @@
 import { FieldDefinition } from './fieldDefinitions'
+import { EntityConstructor } from '../../utils'
 
 export type Interface<T> = { [P in keyof T]: T[P] }
 export type RelationTarget = EntityConstructor
-export type EntityConstructor<T = any> = { new (): T }
-export type DecoratorFunction<T> = (cls: EntityConstructor<T>) => void
 export type FieldsDefinition = Record<string, Interface<FieldDefinition<any>>>
+export { EntityConstructor }

package/src/tsconfig.json

@@ -4,11 +4,7 @@
 		"outDir": "../dist/src"
 	},
 	"references": [
-		{
-			"path": "../../schema/src"
-		},
-		{
-			"path": "../../schema-utils/src"
-		}
+		{ "path": "../../schema/src" },
+		{ "path": "../../schema-utils/src" }
 	]
 }

package/src/utils/decorators.ts

@@ -0,0 +1,2 @@
+export type EntityConstructor<T = any> = { new(): T }
+export type DecoratorFunction<T> = (cls: EntityConstructor<T>) => void

package/src/utils/filterEntityDefinition.ts

@@ -1,4 +1,4 @@
-import { EntityConstructor } from '../model/definition/types'
+import { EntityConstructor } from './decorators'
 
 export const filterEntityDefinition = (definitions: Record<string, unknown>): [string, EntityConstructor][] => Object.entries(definitions)
 	.filter((it): it is [string, EntityConstructor] => isEntityConstructor(it[1]))

package/src/utils/index.ts

@@ -1,3 +1,5 @@
 export * from './assertNever'
 export * from './filterEntityDefinition'
 export * from './tuple'
+export * from './decorators'
+export * from './MetadataStore'

package/tests/tsconfig.json

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

package/tests/unit/extendEntity.test.ts

@@ -2,7 +2,7 @@ import { Model } from '@contember/schema'
 import { assert, test } from 'vitest'
 import { createSchema, SchemaDefinition as def } from '../../src'
 import { extendEntity, FieldDefinition } from '../../src/model/definition'
-import { DecoratorFunction } from '../../src/model/definition/types'
+import { DecoratorFunction } from '../../src/utils'
 
 namespace ExtendedModel {
 	export class Article {