@contember/schema-definition 1.2.0-alpha.9 → 1.2.0-beta.1

package/src/acl/definition/variables.ts

@@ -1,5 +1,5 @@
 import { Role } from './roles'
-import { Acl } from '@contember/schema'
+import { Acl, Input } from '@contember/schema'
 
 export class VariableDefinition<Name extends string = string, Roles extends Role<string> = Role<string>, Variable extends Acl.Variable = Acl.Variable> {
 	constructor(
@@ -10,24 +10,24 @@ export class VariableDefinition<Name extends string = string, Roles extends Role
 	}
 }
 
-
 export const createEntityVariable = <R extends Role<string>, Name extends string>(
 	name: Name,
 	entityName: string,
 	roles: R | R[],
+	fallback?: Input.Condition,
 ): VariableDefinition<Name, R, Acl.EntityVariable> => {
 	return new VariableDefinition(
 		name,
 		Array.isArray(roles) ? roles : [roles],
-		{ type: Acl.VariableType.entity, entityName },
+		{ type: Acl.VariableType.entity, entityName, ...(fallback ? { fallback } : {}) },
 	)
 }
 
-
 export const createPredefinedVariable = <R extends Role<string>, Name extends string>(
 	name: Name,
 	value: Acl.PredefinedVariableValue,
 	roles: R | R[],
+	fallback?: Input.Condition,
 ): VariableDefinition<Name, R, Acl.EntityVariable> => {
 	return new VariableDefinition(
 		name,
@@ -39,10 +39,11 @@ export const createPredefinedVariable = <R extends Role<string>, Name extends st
 export const createConditionVariable = <R extends Role<string>, Name extends string>(
 	name: Name,
 	roles: R | R[],
+	fallback?: Input.Condition,
 ): VariableDefinition<Name, R, Acl.ConditionVariable> => {
 	return new VariableDefinition(
 		name,
 		Array.isArray(roles) ? roles : [roles],
-		{ type: Acl.VariableType.condition  },
+		{ type: Acl.VariableType.condition, ...(fallback ? { fallback } : {}) },
 	)
 }

package/src/createSchema.ts

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

package/src/model/definition/ViewDefinition.ts

@@ -2,7 +2,7 @@ import { extendEntity } from './extensions'
 import { EntityConstructor } from './types'
 
 export const View = (sql: string, { dependencies }: { dependencies?: (() => EntityConstructor[]) | EntityConstructor[] } = {}) =>
-	extendEntity(({ entity, registry }) => {
+	extendEntity(({ entity, entityRegistry }) => {
 		const dependenciesResolved = typeof dependencies === 'function' ? dependencies() : dependencies
 		if (dependenciesResolved?.some(it => it === undefined)) {
 			throw `"undefined" value detected in dependencies of view entity ${entity.name}. This is possibly caused by circular imports.
@@ -18,7 +18,7 @@ dependencies: () => [MyEntity]
 			...entity,
 			view: {
 				sql,
-				...(dependenciesResolved ? { dependencies: dependenciesResolved.map(it => registry.getName(it)) } : {}),
+				...(dependenciesResolved ? { dependencies: dependenciesResolved.map(it => entityRegistry.getName(it)) } : {}),
 			},
 		})
 	})

package/src/model/definition/extensions.ts

@@ -1,10 +1,16 @@
 import { Model } from '@contember/schema'
 import { DecoratorFunction, EntityConstructor, FieldsDefinition } from './types'
-import { EntityRegistry } from './internal'
+import { EntityRegistry, EnumRegistry } from './internal'
+import { NamingConventions } from './NamingConventions'
 
 interface EntityExtensionArgs {
 	entity: Model.Entity
 	definition: FieldsDefinition
+	conventions: NamingConventions
+	enumRegistry: EnumRegistry
+	entityRegistry: EntityRegistry
+
+	/** @deprecated use entityRegistry */
 	registry: EntityRegistry
 }
 

package/src/model/definition/fieldDefinitions/ColumnDefinition.ts

@@ -34,8 +34,8 @@ export class ColumnDefinition extends FieldDefinition<ColumnDefinitionOptions> {
 		return this.withOption('nullable', false)
 	}
 
-	public sequence(options?: Model.ColumnTypeDefinition['sequence']): Interface<ColumnDefinition> {
-		return this.withOption('sequence', options ?? { precedence: 'BY DEFAULT' })
+	public sequence(options?: Partial<Model.ColumnTypeDefinition['sequence']>): Interface<ColumnDefinition> {
+		return this.withOption('sequence', { precedence: 'BY DEFAULT', ...options })
 	}
 
 	public unique(): Interface<ColumnDefinition> {

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

@@ -61,7 +61,14 @@ export class SchemaBuilder {
 					enabled: true,
 				},
 			}
-			return applyEntityExtensions(definition, { entity,  definition: definitionInstance, registry: this.entityRegistry })
+			return applyEntityExtensions(definition, {
+				entity,
+				definition: definitionInstance,
+				registry: this.entityRegistry,
+				entityRegistry: this.entityRegistry,
+				conventions: this.conventions,
+				enumRegistry: this.enumRegistry,
+			})
 		})
 
 		return {

package/tests/unit/extendEntity.test.ts

@@ -0,0 +1,42 @@
+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'
+
+namespace ExtendedModel {
+	export class Article {
+		title = def.stringColumn()
+	}
+
+	const addField = (name: string, field: FieldDefinition<any>): DecoratorFunction<any> => {
+		return extendEntity(({ entity, conventions, entityRegistry, enumRegistry }) => ({
+			...entity,
+			fields: {
+				...entity.fields,
+				[name]: field.createField({
+					name,
+					enumRegistry,
+					entityRegistry,
+					conventions,
+					entityName: entity.name,
+				}),
+			},
+		}))
+	}
+
+	addField('lead', def.stringColumn())(Article)
+}
+
+
+test('add a field to entity using an extension', () => {
+	const schema = createSchema(ExtendedModel)
+
+	assert.deepEqual(schema.model.entities.Article.fields.lead, {
+		columnName: 'lead',
+		name: 'lead',
+		columnType: 'text',
+		type: Model.ColumnType.String,
+		nullable: true,
+	})
+})

package/tests/unit/readAclDefinitions.test.ts

@@ -24,6 +24,32 @@ test('simple definitions', () => {
 	`)
 })
 
+
+namespace RoleOptions {
+	export const publicRole = acl.createRole('public', {
+		debug: true,
+		s3: {
+			foo: 'bar',
+		},
+	})
+}
+
+test('role options', () => {
+	const schema = createSchema(RoleOptions)
+	expect(schema.acl.roles.public).toMatchInlineSnapshot(`
+		{
+		  "debug": true,
+		  "entities": {},
+		  "s3": {
+		    "foo": "bar",
+		  },
+		  "stages": "*",
+		  "variables": {},
+		}
+	`)
+})
+
+
 namespace ModelWithPredicate {
 	export const publicRole = acl.createRole('public')
 
@@ -181,6 +207,72 @@ test('definition with multiple predicates on a single field', () => {
 })
 
 
+namespace ModelWithJoinedPredicateCollision {
+	export const publicRole = acl.createRole('public')
+
+	@acl.allow(publicRole, {
+		when: { isPublishedLoremIpsumDolorSitAmet: { eq: true } },
+		read: ['title'],
+	})
+	@acl.allow(publicRole, {
+		when: { isPublishedLoremIpsumDolorSitAmet: { eq: false } },
+		read: ['title', 'isPublishedLoremIpsumDolorSitAmet'],
+	})
+	@acl.allow(publicRole, {
+		when: { isPublishedLoremIpsumDolorSitAmet: { eq: false } },
+		read: ['isPublishedLoremIpsumDolorSitAmet'],
+	})
+	export class Book {
+		title = def.stringColumn()
+		isPublishedLoremIpsumDolorSitAmet = def.boolColumn()
+	}
+}
+
+test('definition with collision', () => {
+	const schema = createSchema(ModelWithJoinedPredicateCollision)
+	expect(schema.acl.roles.public.entities.Book).toMatchInlineSnapshot(`
+		{
+		  "operations": {
+		    "read": {
+		      "isPublishedLoremIpsumDolorSitAmet": "or_isPublishedLoremIpsumDolor_1",
+		      "title": "or_isPublishedLoremIpsumDolor",
+		    },
+		  },
+		  "predicates": {
+		    "or_isPublishedLoremIpsumDolor": {
+		      "or": [
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": false,
+		          },
+		        },
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": true,
+		          },
+		        },
+		      ],
+		    },
+		    "or_isPublishedLoremIpsumDolor_1": {
+		      "or": [
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": false,
+		          },
+		        },
+		        {
+		          "isPublishedLoremIpsumDolorSitAmet": {
+		            "eq": false,
+		          },
+		        },
+		      ],
+		    },
+		  },
+		}
+	`)
+})
+
+
 namespace ModelWithMultipleRolesForSinglePredicate {
 	export const publicRole = acl.createRole('public')
 	export const adminRole = acl.createRole('admin')