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

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/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)
+})