@contember/schema-utils 2.0.2 → 2.1.0-alpha.10

package/src/dataUtils.ts

@@ -1,7 +1,7 @@
 import { Input, Model, Value } from '@contember/schema'
 
 export interface Providers {
-	uuid: () => string
+	uuid: (args?: { version?: 4 | 7 }) => string
 	now: () => Date
 }
 
@@ -25,9 +25,13 @@ export const resolveDefaultValue = (column: Model.AnyColumn, providers: Pick<Pro
 			break
 		case Model.ColumnType.DateTime:
 		case Model.ColumnType.Date:
+		case Model.ColumnType.Time:
 			if (column.default === 'now') {
 				return providers.now().toISOString()
 			}
+			if (typeof column.default !== 'undefined') {
+				return column.default
+			}
 			break
 		case Model.ColumnType.Uuid:
 			break
@@ -42,13 +46,6 @@ export const resolveDefaultValue = (column: Model.AnyColumn, providers: Pick<Pro
 	throw new NoDataError(`No data for column ${column.name}`)
 }
 
-export const resolvePrimaryGenerator = (column: Model.AnyColumn, providers: Providers): (() => Input.PrimaryValue | undefined) => {
-	if (column.type === Model.ColumnType.Uuid) {
-		return providers.uuid
-	}
-	return () => undefined
-}
-
 export const resolveColumnValue = (
 	{
 		entity,
@@ -60,12 +57,18 @@ export const resolveColumnValue = (
 		input: Input.ColumnValue | undefined
 	},
 	providers: Providers,
+	options: {
+		uuidVersion?: 4 | 7
+	},
 ): Value.FieldValue | undefined => {
 	if (input !== undefined) {
 		return input
 	}
 	if (entity.primary === column.name) {
-		return resolvePrimaryGenerator(column, providers)()
+		if (column.type === Model.ColumnType.Uuid) {
+			return providers.uuid({ version: options.uuidVersion })
+		}
+		return undefined
 	}
 
 	return resolveDefaultValue(column, providers)

package/src/definition-generator/DefinitionCodeGenerator.ts

@@ -45,7 +45,7 @@ ${Object.values(entity.fields).map(field => this.generateField({ field, entity,
 }\n`
 	}
 
-	private generateUniqueConstraint({ entity, constraint }: { entity: Model.Entity; constraint: Model.UniqueConstraint }): string {
+	private generateUniqueConstraint({ entity, constraint }: { entity: Model.Entity; constraint: Model.UniqueConstraint | Model.UniqueIndex }): string {
 		const fieldsList = `${constraint.fields.map(it => printJsValue(it)).join(', ')}`
 
 		return `@c.Unique(${fieldsList})`
@@ -234,6 +234,7 @@ const ColumnToMethodMapping: {
 	[Model.ColumnType.Bool]: 'boolColumn',
 	[Model.ColumnType.Date]: 'dateColumn',
 	[Model.ColumnType.DateTime]: 'dateTimeColumn',
+	[Model.ColumnType.Time]: 'timeColumn',
 	[Model.ColumnType.Json]: 'jsonColumn',
 	[Model.ColumnType.Double]: 'doubleColumn',
 	[Model.ColumnType.Uuid]: 'uuidColumn',

package/src/model/modelUtils.ts

@@ -65,7 +65,7 @@ export const tryGetColumnName = (schema: Model.Schema, entity: Model.Entity, fie
 export const getColumnType = (schema: Model.Schema, entity: Model.Entity, fieldName: string): string => {
 	return acceptFieldVisitor(schema, entity, fieldName, {
 		// TODO solve enum handling properly maybe we should distinguish between domain and column type
-		visitColumn: ({ column }) => (column.type === Model.ColumnType.Enum ? 'text' : column.columnType),
+		visitColumn: ({ column }) => (column.type === Model.ColumnType.Enum ? 'text' : column.columnType) + (column.list ? '[]' : ''),
 		visitRelation: ({ entity, relation, targetEntity }) => {
 			if (isIt<Model.JoiningColumnRelation>(relation, 'joiningColumn')) {
 				return getColumnType(schema, targetEntity, targetEntity.primary)

package/src/model/resolveDefaultColumnType.ts

@@ -17,6 +17,8 @@ export const resolveDefaultColumnType = (type: Exclude<Model.ColumnType, Model.C
 			return 'timestamptz'
 		case Model.ColumnType.Date:
 			return 'date'
+		case Model.ColumnType.Time:
+			return 'time'
 		case Model.ColumnType.Json:
 			return 'jsonb'
 		default:

package/src/schemaNormalizer.ts

@@ -24,6 +24,7 @@ export const normalizeSchema = <S extends Schema>(schema: S): S => {
 					content: {
 						export: true,
 						import: true,
+						refreshMaterializedView: true,
 						...adminRoleDefinition.content,
 					},
 					system: {
@@ -47,6 +48,7 @@ export const normalizeSchema = <S extends Schema>(schema: S): S => {
 					content: {
 						export: true,
 						import: true,
+						refreshMaterializedView: true,
 						...contentAdminRoleDefinition.content,
 					},
 					system: {

package/src/type-schema/acl.ts

@@ -39,6 +39,7 @@ const contentPermissionsSchema = Typesafe.partial({
 	assumeMembership: membershipMatchRuleSchema,
 	export: Typesafe.boolean,
 	import: Typesafe.boolean,
+	refreshMaterializedView: Typesafe.boolean,
 })
 const contentSchemaCheck: Typesafe.Equals<Acl.ContentPermissions, ReturnType<typeof contentPermissionsSchema>> = true
 
@@ -95,6 +96,7 @@ const entityOperationsSchema = Typesafe.partial({
 	update: fieldPermissionsSchema,
 	delete: Typesafe.union(Typesafe.string, Typesafe.boolean),
 	customPrimary: Typesafe.boolean,
+	refreshMaterializedView: Typesafe.boolean,
 	noRoot: Typesafe.array(Typesafe.enumeration('create', 'read', 'update', 'delete')),
 })
 

package/src/type-schema/condition.ts

@@ -67,6 +67,7 @@ const resolveColumnTypeSchema = (type: Model.ColumnType) => {
 		// todo: validate format of string-like inputs uuid, date, enum
 		case Model.ColumnType.Date:
 		case Model.ColumnType.DateTime:
+		case Model.ColumnType.Time:
 		case Model.ColumnType.Uuid:
 		case Model.ColumnType.Enum:
 		case Model.ColumnType.String:

package/src/type-schema/model.ts

@@ -130,8 +130,10 @@ const columnSchema = Typesafe.intersection(
 	}),
 	Typesafe.partial({
 		typeAlias: Typesafe.string,
-		default: Typesafe.union(Typesafe.string, Typesafe.number, Typesafe.boolean, Typesafe.null_),
+		list: Typesafe.boolean,
+		default: Typesafe.anyJson,
 		sequence: intersectionSchema as Typesafe.Type<Model.AnyColumn['sequence']>,
+		collation: Typesafe.string as Typesafe.Type<Model.AnyColumn['collation']>,
 	}),
 )
 const columnSchemaCheck: Typesafe.Equals<Model.AnyColumn, ReturnType<typeof columnSchema>> = true
@@ -153,13 +155,15 @@ const viewSchemaInner = Typesafe.intersection(
 	}),
 	Typesafe.partial({
 		dependencies: Typesafe.array(Typesafe.string),
+		idSource: Typesafe.array(Typesafe.string),
+		materialized: Typesafe.boolean,
 	}),
 )
 const viewSchemaCheck: Typesafe.Equals<Model.View, ReturnType<typeof viewSchemaInner>> = true
 const viewSchema: Typesafe.Type<Model.View> = viewSchemaInner
 
 
-const indexLike: Typesafe.Type<{readonly fields: readonly string[]; readonly name?: string | undefined}> = Typesafe.intersection(
+const indexSchemaBase = Typesafe.intersection(
 	Typesafe.object({
 		fields: Typesafe.array(Typesafe.string),
 	}),
@@ -167,22 +171,37 @@ const indexLike: Typesafe.Type<{readonly fields: readonly string[]; readonly nam
 		name: Typesafe.string,
 	}),
 )
+const indexCheck: Typesafe.Equals<Model.Index, ReturnType<typeof indexSchemaBase>> = true
 
 const indexesSchema = Typesafe.coalesce<Model.Indexes, Model.Indexes>(
 	Typesafe.preprocess(
-		Typesafe.array(indexLike),
+		Typesafe.array(indexSchemaBase),
 		it => it?.constructor === Object ? Object.values(it) : it,
 	),
 	[],
 )
 
 const uniqueConstraint = Typesafe.intersection(
-	indexLike,
+	Typesafe.object({
+		fields: Typesafe.array(Typesafe.string),
+	}),
 	Typesafe.partial({
 		timing: Typesafe.enumeration('deferrable', 'deferred'),
+		name: Typesafe.string,
+		index: Typesafe.literal(false),
+	}),
+)
+const uniqueIndex = Typesafe.intersection(
+	Typesafe.object({
+		fields: Typesafe.array(Typesafe.string),
+		index: Typesafe.literal(true),
+	}),
+	Typesafe.partial({
+		nulls: Typesafe.enumeration('distinct', 'not distinct'),
 	}),
 )
 const uniqueConstraintCheck: Typesafe.Equals<Model.UniqueConstraint, ReturnType<typeof uniqueConstraint>> = true
+const uniqueIndexCheck: Typesafe.Equals<Model.UniqueIndex, ReturnType<typeof uniqueIndex>> = true
 
 const entitySchema = Typesafe.intersection(
 	Typesafe.object({
@@ -191,8 +210,8 @@ const entitySchema = Typesafe.intersection(
 		primaryColumn: Typesafe.string,
 		tableName: Typesafe.string,
 		fields: Typesafe.record(Typesafe.string, fieldSchema),
-		unique: Typesafe.preprocess<Model.UniqueConstraints>(
-			Typesafe.array(uniqueConstraint),
+		unique: Typesafe.preprocess<Model.Uniques>(
+			Typesafe.array(Typesafe.union(uniqueConstraint, uniqueIndex)),
 			it => it?.constructor === Object ? Object.values(it) : it,
 		),
 		indexes: indexesSchema,

package/src/type-schema/settings.ts

@@ -11,6 +11,7 @@ export const settingsSchema = Typesafe.partial({
 		useExistsInHasManyFilter: Typesafe.boolean,
 		fullDateTimeResponse: Typesafe.boolean,
 		shortDateResponse: Typesafe.boolean,
+		uuidVersion: Typesafe.union(Typesafe.literal(4), Typesafe.literal(7)),
 	}),
 })
 

package/src/validation/ModelValidator.ts

@@ -1,6 +1,6 @@
 import { Model } from '@contember/schema'
 import { ErrorBuilder, ValidationError } from './errors'
-import { acceptEveryFieldVisitor, getTargetEntity, isInverseRelation, isOwningRelation } from '../model'
+import { acceptEveryFieldVisitor, getTargetEntity, isColumn, isInverseRelation, isOwningRelation } from '../model'
 
 const IDENTIFIER_PATTERN = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 const RESERVED_WORDS = ['and', 'or', 'not']
@@ -52,18 +52,23 @@ export class ModelValidator {
 			}
 		}
 		this.validateUniqueConstraints(
-			entity.unique,
-			new Set(Object.keys(entity.fields)),
+			entity,
 			errors.for('unique'),
 		)
 		this.validateColumnNamesCollision(entity, errors)
 	}
 
-	private validateUniqueConstraints(uniqueConstraints: Model.Entity['unique'], fields: Set<string>, errors: ErrorBuilder): void {
-		for (const constraint of uniqueConstraints) {
+	private validateUniqueConstraints(entity: Model.Entity, errors: ErrorBuilder): void {
+		for (const constraint of entity.unique) {
+			if (entity.view?.materialized && !constraint.index) {
+				errors.add('MODEL_INVALID_CONSTRAINT', 'For materialized views, Unique must be defined as an index. Please set index: true.')
+			}
 			for (const field of constraint.fields) {
-				if (!fields.has(field)) {
+				const fieldDef = entity.fields[field]
+				if (!fieldDef) {
 					errors.add('MODEL_UNDEFINED_FIELD', `Referenced field ${field} in a constraint does not exists`)
+				} else if (isColumn(fieldDef) && fieldDef.list) {
+					errors.add('MODEL_INVALID_FIELD', `Field ${field} in a unique constraint cannot be an array`)
 				}
 			}
 		}
@@ -190,11 +195,6 @@ export class ModelValidator {
 			}
 		} else {
 			const inversedBy = field.inversedBy
-			if (targetEntity.view) {
-				if ('joiningColumn' in field) {
-					return errors.add('MODEL_INVALID_VIEW_USAGE', `View entity ${targetEntity.name} cannot be referenced from an owning relation. Try switching the owning side.`)
-				}
-			}
 			if (inversedBy) {
 				const targetField = targetEntity.fields[inversedBy]
 				const relationDescription = `Target relation ${targetEntityName}::${inversedBy}:`

package/src/validation/errors.ts

@@ -1,6 +1,7 @@
 export type ValidationErrorCode =
 	| 'MODEL_NAME_MISMATCH'
 	| 'MODEL_UNDEFINED_FIELD'
+	| 'MODEL_INVALID_FIELD'
 	| 'MODEL_UNDEFINED_ENTITY'
 	| 'MODEL_RELATION_REQUIRED'
 	| 'MODEL_INVALID_RELATION_DEFINITION'
@@ -8,6 +9,7 @@ export type ValidationErrorCode =
 	| 'MODEL_INVALID_VIEW_USAGE'
 	| 'MODEL_INVALID_IDENTIFIER'
 	| 'MODEL_INVALID_ENTITY_NAME'
+	| 'MODEL_INVALID_CONSTRAINT'
 	| 'MODEL_NAME_COLLISION'
 
 	| 'ACL_INVALID_CONDITION'

package/tests/cases/unit/modelValidator.test.ts

@@ -91,3 +91,22 @@ test('column name collision', () => {
 		},
 	])
 })
+
+
+namespace ViewRelations {
+	@c.View('SELECT 1')
+	export class Foo {
+		bars = c.oneHasMany(Bar, 'foo')
+	}
+
+	@c.View('SELECT 1')
+	export class Bar {
+		foo = c.manyHasOne(Foo, 'bars')
+	}
+}
+
+test('view relations', () => {
+	const schema = createSchema(ViewRelations)
+	const validator = new ModelValidator(schema.model)
+	expect(validator.validate()).toStrictEqual([])
+})