@contember/binding-common 2.0.0-alpha.17

package/src/queryLanguage/QueryLanguageError.ts

@@ -0,0 +1 @@
+export class QueryLanguageError extends Error {}

package/src/queryLanguage/index.ts

@@ -0,0 +1,5 @@
+export * from './MarkerFactory'
+export * from './Parser'
+export * from './QueryLanguage'
+export * from './QueryLanguageError'
+export * from './tokenList'

package/src/queryLanguage/tokenList.ts

@@ -0,0 +1,177 @@
+import { createToken, Lexer } from 'chevrotain'
+
+export namespace TokenRegExps {
+	export const entityIdentifier = /[A-Z_]\w*/
+	export const identifier = /[a-zA-Z_]\w*/
+
+	export const dotSeparatedIdentifier = /^[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*$/
+}
+
+const identifier = createToken({
+	name: 'Identifier',
+	pattern: TokenRegExps.identifier,
+})
+
+export const tokens = {
+	WhiteSpace: createToken({
+		name: 'WhiteSpace',
+		pattern: /\s+/,
+		group: Lexer.SKIPPED,
+	}),
+
+	EntityIdentifier: createToken({
+		name: 'EntityIdentifier',
+		pattern: TokenRegExps.entityIdentifier,
+	}),
+
+	Identifier: identifier,
+
+	DollarSign: createToken({
+		name: 'DollarSign',
+		pattern: /\$/,
+	}),
+
+	Dot: createToken({
+		name: 'Dot',
+		pattern: /\./,
+	}),
+
+	Comma: createToken({
+		name: 'Comma',
+		pattern: /,/,
+	}),
+
+	Colon: createToken({
+		name: 'Colon',
+		pattern: /:/,
+	}),
+
+	Slash: createToken({
+		name: 'Slash',
+		pattern: /\//,
+	}),
+
+	NumberLiteral: createToken({
+		name: 'NumberLiteral',
+		pattern: /-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/,
+	}),
+
+	StringLiteral: createToken({
+		name: 'StringLiteral',
+		pattern: /'(:?[^\\']|\\(:?[bfnrtv"'\\/]|u[0-9a-fA-F]{4}))*'|"(:?[^\\"]|\\(:?[bfnrtv"'\\/]|u[0-9a-fA-F]{4}))*"/,
+	}),
+
+	LeftParenthesis: createToken({
+		name: 'LeftParenthesis',
+		pattern: /\(/,
+	}),
+
+	RightParenthesis: createToken({
+		name: 'RightParenthesis',
+		pattern: /\)/,
+	}),
+
+	LeftBracket: createToken({
+		name: 'LeftBracket',
+		pattern: /\[/,
+	}),
+
+	RightBracket: createToken({
+		name: 'RightBracket',
+		pattern: /]/,
+	}),
+
+	NotEquals: createToken({
+		name: 'NotEquals',
+		pattern: /!=/,
+	}),
+
+	True: createToken({
+		name: 'True',
+		pattern: /true/,
+		longer_alt: identifier,
+	}),
+
+	False: createToken({
+		name: 'False',
+		pattern: /false/,
+		longer_alt: identifier,
+	}),
+
+	Null: createToken({
+		name: 'Null',
+		pattern: /null/,
+		longer_alt: identifier,
+	}),
+
+	Equals: createToken({
+		name: 'Equals',
+		pattern: /=/,
+	}),
+
+	Not: createToken({
+		name: 'Not',
+		pattern: /!/,
+	}),
+
+	And: createToken({
+		name: 'And',
+		pattern: /&&/,
+	}),
+
+	Or: createToken({
+		name: 'Or',
+		pattern: /\|\|/,
+	}),
+
+	LowerEqual: createToken({
+		name: 'LowerEqual',
+		pattern: /<=/,
+	}),
+
+	GreaterEqual: createToken({
+		name: 'GreaterEqual',
+		pattern: />=/,
+	}),
+
+	LowerThan: createToken({
+		name: 'LowerThan',
+		pattern: /</,
+	}),
+
+	GreaterThan: createToken({
+		name: 'GreaterThan',
+		pattern: />/,
+	}),
+}
+
+const tokenList = [
+	tokens.WhiteSpace,
+	tokens.True,
+	tokens.False,
+	tokens.Null,
+	tokens.EntityIdentifier,
+	tokens.Identifier,
+	tokens.DollarSign,
+	tokens.Dot,
+	tokens.Comma,
+	tokens.Colon,
+	tokens.Slash,
+	tokens.StringLiteral,
+	tokens.NumberLiteral,
+	tokens.LeftParenthesis,
+	tokens.RightParenthesis,
+	tokens.LeftBracket,
+	tokens.RightBracket,
+	tokens.NotEquals,
+	tokens.Equals,
+	tokens.Not,
+	tokens.GreaterEqual,
+	tokens.GreaterThan,
+	tokens.LowerEqual,
+	tokens.LowerThan,
+	tokens.And,
+	tokens.Or,
+]
+
+export { tokenList }

package/src/schema/RawSchema.ts

@@ -0,0 +1,7 @@
+import type { RawSchemaEntity } from './RawSchemaEntity'
+import type { RawSchemaEnum } from './RawSchemaEnum'
+
+export interface RawSchema {
+	enums: RawSchemaEnum[]
+	entities: RawSchemaEntity[]
+}

package/src/schema/RawSchemaEntity.ts

@@ -0,0 +1,12 @@
+import type { EntityName } from '../treeParameters'
+import type { SchemaColumn } from './SchemaColumn'
+import type { SchemaRelation } from './SchemaRelation'
+
+export type RawSchemaFields = Array<SchemaRelation | SchemaColumn>
+
+export interface RawSchemaEntity {
+	name: EntityName
+	customPrimaryAllowed: boolean
+	fields: RawSchemaFields
+	unique: { fields: string[] }[]
+}

package/src/schema/RawSchemaEnum.ts

@@ -0,0 +1,6 @@
+import type { SchemaEnumName } from './SchemaEnums'
+
+export interface RawSchemaEnum {
+	name: SchemaEnumName
+	values: string[]
+}

package/src/schema/Schema.ts

@@ -0,0 +1,46 @@
+import type { EntityName, FieldName } from '../treeParameters'
+import type { SchemaField } from './SchemaField'
+import type { SchemaStore } from './SchemaStore'
+import { SchemaEntity } from './SchemaEntity'
+import { SchemaColumn } from './SchemaColumn'
+import { SchemaRelation } from './SchemaRelation'
+import { SchemaEnumName } from './SchemaEnums'
+import { throwBindingError } from '../BindingError'
+
+export class Schema {
+	public constructor(private readonly store: SchemaStore) {}
+
+	public getEnumValues(enumName: SchemaEnumName): string[] {
+		return Array.from(this.store.enums.get(enumName) ?? throwBindingError(`Missing schema for enum ${enumName}`))
+	}
+
+	public getEntityOrUndefined(entityName: EntityName): SchemaEntity | undefined {
+		return this.store.entities.get(entityName)
+	}
+
+	public getEntityNames(): string[] {
+		return Array.from(this.store.entities.keys())
+	}
+
+	public getEntity(entityName: EntityName): SchemaEntity {
+		return this.getEntityOrUndefined(entityName) ?? throwBindingError(`Missing schema for entity ${entityName}`)
+	}
+
+	public getEntityFieldOrUndefined(entityName: EntityName, fieldName: FieldName): SchemaField | undefined {
+		return this.store.entities.get(entityName)?.fields.get(fieldName)
+	}
+
+	public getEntityField(entityName: EntityName, fieldName: FieldName): SchemaField {
+		return this.getEntityFieldOrUndefined(entityName, fieldName) ?? throwBindingError(`Missing schema for field ${entityName}.${fieldName}`)
+	}
+
+	public getEntityColumn(entityName: EntityName, fieldName: FieldName): SchemaColumn {
+		const field = this.getEntityField(entityName, fieldName)
+		return field.__typename === '_Column' ? field : throwBindingError(`Field ${entityName}.${fieldName} is not of type column`)
+	}
+
+	public getEntityRelation(entityName: EntityName, fieldName: FieldName): SchemaRelation {
+		const field = this.getEntityField(entityName, fieldName)
+		return field.__typename === '_Relation' ? field : throwBindingError(`Field ${entityName}.${fieldName} is not of type relation`)
+	}
+}

package/src/schema/SchemaColumn.ts

@@ -0,0 +1,15 @@
+import type { FieldName } from '../treeParameters'
+import type { SchemaColumnType } from './SchemaColumnType'
+import type { SchemaEnumName } from './SchemaEnums'
+
+export interface SchemaColumn {
+	__typename: '_Column'
+	defaultValue: string | number | boolean | null // JSON
+	name: FieldName
+	nullable: boolean
+	type: SchemaColumnType
+	enumName: SchemaEnumName | null
+
+	// rules
+	// validators
+}

package/src/schema/SchemaColumnType.ts

@@ -0,0 +1,3 @@
+export type SchemaKnownColumnType = 'Bool' | 'Date' | 'DateTime' | 'Double' | 'Enum' | 'Integer' | 'String' | 'Uuid'
+
+export type SchemaColumnType = SchemaKnownColumnType | string

package/src/schema/SchemaEntities.ts

@@ -0,0 +1,4 @@
+import type { EntityName } from '../treeParameters'
+import type { SchemaEntity } from './SchemaEntity'
+
+export type SchemaEntities = Map<EntityName, SchemaEntity>

package/src/schema/SchemaEntity.ts

@@ -0,0 +1,10 @@
+import type { EntityName } from '../treeParameters'
+import type { SchemaFields } from './SchemaFields'
+import type { SchemaUniqueConstraint } from './SchemaUniqueConstraint'
+
+export interface SchemaEntity {
+	name: EntityName
+	customPrimaryAllowed: boolean
+	fields: SchemaFields
+	unique: SchemaUniqueConstraint[]
+}

package/src/schema/SchemaEnums.ts

@@ -0,0 +1,3 @@
+export type SchemaEnumName = string
+export type SchemaEnumValues = Set<string>
+export type SchemaEnums = Map<SchemaEnumName, SchemaEnumValues>

package/src/schema/SchemaField.ts

@@ -0,0 +1,4 @@
+import type { SchemaColumn } from './SchemaColumn'
+import type { SchemaRelation } from './SchemaRelation'
+
+export type SchemaField = SchemaRelation | SchemaColumn

package/src/schema/SchemaFields.ts

@@ -0,0 +1,4 @@
+import type { FieldName } from '../treeParameters'
+import type { SchemaField } from './SchemaField'
+
+export type SchemaFields = Map<FieldName, SchemaField>

package/src/schema/SchemaLoader.ts

@@ -0,0 +1,64 @@
+import type { GraphQlClient, GraphQlClientRequestOptions } from '@contember/client'
+import type { RawSchema } from './RawSchema'
+import { Schema } from './Schema'
+import { SchemaPreprocessor } from './SchemaPreprocessor'
+
+export class SchemaLoader {
+	private static readonly schemaLoadCache: Map<string, Promise<Schema>> = new Map()
+
+	private static readonly schemaQuery =
+		'query {\n' +
+		'  schema {\n' +
+		'    enums {\n' +
+		'      name\n' +
+		'      values\n' +
+		'    }\n' +
+		'    entities {\n' +
+		'      name\n' +
+		'      customPrimaryAllowed\n' +
+		'      unique {\n' +
+		'        fields\n' +
+		'      }\n' +
+		'      fields {\n' +
+		'        __typename\n' +
+		'        name\n' +
+		'        type\n' +
+		'        nullable\n' +
+		'        ... on _Column {\n' +
+		'          enumName\n' +
+		'          defaultValue\n' +
+		'        }\n' +
+		'        ... on _Relation {\n' +
+		'          side\n' +
+		'          targetEntity\n' +
+		'          ownedBy\n' +
+		'          inversedBy\n' +
+		'          onDelete\n' +
+		'          orphanRemoval\n' +
+		'          orderBy {\n' +
+		'            path\n' +
+		'            direction\n' +
+		'          }\n' +
+		'        }\n' +
+		'      }\n' +
+		'    }\n' +
+		'  }\n' +
+		'}'
+
+	public static async loadSchema(
+		client: GraphQlClient,
+		options?: GraphQlClientRequestOptions,
+	): Promise<Schema> {
+
+		const existing = this.schemaLoadCache.get(client.apiUrl)
+		if (existing !== undefined) {
+			return existing
+		}
+		const schemaPromise = (async () => {
+			const raw = await client.execute<{ schema: RawSchema }>(this.schemaQuery, options)
+			return new Schema(SchemaPreprocessor.processRawSchema(raw.schema))
+		})()
+		this.schemaLoadCache.set(client.apiUrl, schemaPromise)
+		return await schemaPromise
+	}
+}

package/src/schema/SchemaPreprocessor.ts

@@ -0,0 +1,51 @@
+import type { RawSchema } from './RawSchema'
+import type { RawSchemaEntity, RawSchemaFields } from './RawSchemaEntity'
+import type { RawSchemaEnum } from './RawSchemaEnum'
+import type { SchemaEntities } from './SchemaEntities'
+import type { SchemaEnums } from './SchemaEnums'
+import type { SchemaFields } from './SchemaFields'
+import type { SchemaStore } from './SchemaStore'
+
+export class SchemaPreprocessor {
+	public static processRawSchema(rawSchema: RawSchema): SchemaStore {
+		return {
+			enums: this.processRawEnums(rawSchema.enums),
+			entities: this.processRawEntities(rawSchema.entities),
+		}
+	}
+
+	private static processRawEnums(rawEnums: RawSchemaEnum[]): SchemaEnums {
+		const enums: SchemaEnums = new Map()
+
+		for (const { name, values } of rawEnums) {
+			enums.set(name, new Set(values))
+		}
+
+		return enums
+	}
+
+	private static processRawEntities(rawEntities: RawSchemaEntity[]): SchemaEntities {
+		const entities: SchemaEntities = new Map()
+
+		for (const entity of rawEntities) {
+			entities.set(entity.name, {
+				customPrimaryAllowed: entity.customPrimaryAllowed,
+				fields: this.processRawFields(entity.fields),
+				name: entity.name,
+				unique: entity.unique.map(it => ({ fields: new Set(it.fields) })),
+			})
+		}
+
+		return entities
+	}
+
+	private static processRawFields(rawFields: RawSchemaFields): SchemaFields {
+		const fields: SchemaFields = new Map()
+
+		for (const field of rawFields) {
+			fields.set(field.name, field)
+		}
+
+		return fields
+	}
+}

package/src/schema/SchemaRelation.ts

@@ -0,0 +1,29 @@
+import type { EntityName, FieldName } from '../treeParameters'
+import type { SchemaRelationOrderBy } from './SchemaRelationOrderBy'
+
+export interface BaseRelation {
+	__typename: '_Relation'
+
+	name: FieldName
+	// This *CAN* be null because the whole notion of nullability doesn't make sense for ManyHasMany
+	nullable: boolean | null
+	onDelete: 'restrict' | 'cascade' | 'setNull' | null
+	orderBy: SchemaRelationOrderBy[] | null
+	orphanRemoval: boolean | null
+	targetEntity: EntityName
+	type: 'OneHasOne' | 'OneHasMany' | 'ManyHasOne' | 'ManyHasMany'
+}
+
+export interface OwningRelation extends BaseRelation {
+	side: 'owning'
+	inversedBy: FieldName | null
+	ownedBy?: never
+}
+
+export interface InverseRelation extends BaseRelation {
+	side: 'inverse'
+	ownedBy: FieldName
+	inversedBy?: never
+}
+
+export type SchemaRelation = OwningRelation | InverseRelation

package/src/schema/SchemaRelationOrderBy.ts

@@ -0,0 +1,4 @@
+export interface SchemaRelationOrderBy {
+	path: string[]
+	direction: 'asc' | 'desc'
+}

package/src/schema/SchemaStore.ts

@@ -0,0 +1,8 @@
+import type { SchemaEntities } from './SchemaEntities'
+import type { SchemaEnums } from './SchemaEnums'
+
+// This should comprise of just structured-cloneable data structures.
+export interface SchemaStore {
+	enums: SchemaEnums
+	entities: SchemaEntities
+}

package/src/schema/SchemaUniqueConstraint.ts

@@ -0,0 +1,5 @@
+import type { FieldName } from '../treeParameters'
+
+export interface SchemaUniqueConstraint {
+	fields: Set<FieldName>
+}

package/src/schema/index.ts

@@ -0,0 +1,15 @@
+export * from './RawSchema'
+export * from './Schema'
+export * from './SchemaColumn'
+export * from './SchemaColumnType'
+export * from './SchemaEntities'
+export * from './SchemaEntity'
+export * from './SchemaEnums'
+export * from './SchemaField'
+export * from './SchemaFields'
+export * from './SchemaLoader'
+export * from './SchemaPreprocessor'
+export * from './SchemaRelation'
+export * from './SchemaRelationOrderBy'
+export * from './SchemaStore'
+export * from './SchemaUniqueConstraint'

package/src/treeParameters/EventListenersStore.ts

@@ -0,0 +1,105 @@
+type AnyFunction = (...args: any[]) => any
+export type GenericEventsMap = {
+	[K in string]: (...args: any[]) => void | AnyFunction | Promise<void | AnyFunction>
+}
+
+export class EventListenersStore<Events extends GenericEventsMap> {
+
+	constructor(
+		private readonly parentStoreGetter?: () => EventListenersStore<Events> | undefined,
+		private listeners?: Map<string, Set<Events[any]>>,
+	) {}
+
+	set<Type extends keyof Events>(event: { type: Type; key?: string }, listeners: Set<Events[Type]>): void {
+		this.listeners ??= new Map()
+		this.listeners.set(this.formatMapEntryKey(event), listeners)
+	}
+
+	delete<Type extends keyof Events>(event: { type: Type; key?: string }) {
+		if (!this.listeners) {
+			return
+		}
+		this.listeners.delete(this.formatMapEntryKey(event))
+	}
+
+	deleteByType<Type extends keyof Events>(type: Type) {
+		if (!this.listeners) {
+			return
+		}
+		const prefix = this.formatMapEntryKey({ type, key: '' })
+		for (const eventType of this.listeners.keys()) {
+			if (eventType.startsWith(prefix)) {
+				this.listeners.delete(eventType)
+			}
+		}
+	}
+
+	get<Type extends keyof Events>(event: { type: Type; key?: string }): Set<Events[Type]> | undefined {
+		if (!this.listeners) {
+			return undefined
+		}
+		const ownListeners = this.listeners.get(this.formatMapEntryKey(event))
+		const parentListeners = this.parentStoreGetter?.()?.get(event)
+		if (!parentListeners) {
+			return ownListeners
+		} else if (!ownListeners) {
+			return parentListeners
+		}
+		return new Set([...ownListeners, ...parentListeners])
+	}
+
+	invoke<Type extends keyof Events>(event: { type: Type; key?: string }, ...args: Parameters<Events[Type]>): void {
+		if (!this.listeners) {
+			return
+		}
+		const listeners = this.get(event)
+		if (listeners) {
+			for (const listener of listeners) {
+				listener(...args)
+			}
+		}
+	}
+
+	add<Type extends keyof Events>(event: { type: Type; key?: string }, handler: Events[Type]): () => void {
+		const key = this.formatMapEntryKey(event)
+		let eventListeners = this.addInternal(key, handler)
+		return () => eventListeners?.delete(handler)
+	}
+
+	clone(): EventListenersStore<Events> {
+		if (!this.listeners) {
+			return new EventListenersStore<Events>(this.parentStoreGetter)
+		}
+		const store: EventListenersStore<Events> = new EventListenersStore(this.parentStoreGetter, new Map())
+		for (const [key, value] of this.listeners.entries()) {
+			store.listeners!.set(key, new Set(value))
+		}
+		return store
+	}
+
+	append(other: EventListenersStore<Events>) {
+		if (!other.listeners) {
+			return
+		}
+		for (const [eventKey, otherListeners] of other.listeners) {
+			for (const listener of otherListeners) {
+				this.addInternal(eventKey, listener)
+			}
+		}
+	}
+
+	private formatMapEntryKey(event: { type: keyof Events; key?: string }): string {
+		return event.key ? `${(event.type as string)}_${event.key ?? ''}` : (event.type as string)
+	}
+
+	private addInternal<Type extends keyof Events>(key: string, handler: Events[Type]) {
+		this.listeners ??= new Map()
+		let eventListeners = this.listeners.get(key)
+		if (!eventListeners) {
+			eventListeners = new Set()
+			this.listeners.set(key, eventListeners)
+		}
+		eventListeners.add(handler)
+		return eventListeners
+	}
+}