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

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

@@ -44,6 +44,7 @@ export default class SchemaBuilderInternal {
 			eventLog: {
 				enabled: true,
 			},
+			...(options.orderBy !== undefined ? { orderBy: options.orderBy } : {}),
 		}
 	}
 

package/src/model/definition/IndexDefinition.ts

@@ -1,6 +1,6 @@
-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 function Index<T>(options: IndexOptions<T>): DecoratorFunction<T>

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,6 +1,6 @@
-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 function Unique<T>(options: UniqueOptions<T>): DecoratorFunction<T>

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/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 {

package/tests/unit/readActions.test.ts

@@ -0,0 +1,54 @@
+import { SchemaDefinition as def, ActionsDefinition as actions } from '../../src'
+import { Model } from '@contember/schema'
+import { test } from 'vitest'
+import { createActions } from '../../src/actions/definition'
+
+namespace SimpleActions {
+
+	@actions.watch({
+		name: 'book_watch',
+		watch: `
+			title
+			tags {
+				name
+			}
+		`,
+		webhook: '%webhookUrl%/book/updated',
+	})
+	export class Book {
+		title = def.stringColumn()
+		tags = def.manyHasMany(Tag)
+		category = def.manyHasOne(Category)
+	}
+
+	export class Tag {
+		locales = def.oneHasMany(TagLocale, 'tag')
+	}
+
+	@def.Unique('tag', 'locale')
+	export class TagLocale {
+		tag = def.manyHasOne(Tag, 'locales')
+		name = def.stringColumn()
+		locale = def.manyHasOne(Locale)
+	}
+
+
+	export class Category {
+		locales = def.oneHasMany(CategoryLocale, 'category')
+	}
+
+	@def.Unique('category', 'locale')
+	export class CategoryLocale {
+		category = def.manyHasOne(Category, 'locales')
+		name = def.stringColumn()
+		locale = def.manyHasOne(Locale)
+	}
+
+	export class Locale {
+		code = def.stringColumn().notNull().unique()
+	}
+}
+
+test('xxx', () => {
+	createActions(SimpleActions)
+})

package/dist/src/acl/definition/internal/MetadataStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetadataStore.d.ts","sourceRoot":"","sources":["../../../../../src/acl/definition/internal/MetadataStore.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAA;AAEzB,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,CAAA;IACtB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAA;CAC1D;AAED,eAAO,MAAM,mBAAmB,0CAe/B,CAAA"}

package/dist/src/acl/definition/internal/MetadataStore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MetadataStore.js","sourceRoot":"","sources":["../../../../../src/acl/definition/internal/MetadataStore.ts"],"names":[],"mappings":";;;AAAA,4BAAyB;AAOlB,MAAM,mBAAmB,GAAG,CAAI,YAAe,EAAoB,EAAE;IAC3E,MAAM,GAAG,GAAG,MAAM,EAAE,CAAA;IACpB,MAAM,GAAG,GAAG,CAAC,MAAc,EAAK,EAAE;QACjC,OAAO,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC;YACtC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC;YAClC,CAAC,CAAC,YAAY,CAAA;IAChB,CAAC,CAAA;IACD,OAAO;QACN,GAAG;QACH,MAAM,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE;YAC7B,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAAA;YAC3B,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC,CAAA;YACtC,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,CAAC,CAAA;QACjD,CAAC;KACD,CAAA;AACF,CAAC,CAAA;AAfY,QAAA,mBAAmB,uBAe/B"}