@contember/schema-definition 1.3.0-beta.4 → 1.3.0-rc.2

package/src/model/definition/OrderByDefinition.ts

@@ -3,22 +3,37 @@ import { extendEntity } from './extensions'
 import { DecoratorFunction } from '../../utils'
 
 
-export type OrderByOptions = { path: string[]; direction?: Model.OrderDirection | `${Model.OrderDirection}` }
+export type OrderByDirection = Model.OrderDirection | `${Model.OrderDirection}`
+export type OrderByOptions = { path: string[]; direction?: OrderByDirection }
 
 
 export function OrderBy<T>(options: OrderByOptions): DecoratorFunction<T>
-export function OrderBy<T>(path: (keyof T), direction?: Model.OrderDirection | `${Model.OrderDirection}`): DecoratorFunction<T>
-export function OrderBy<T>(options: OrderByOptions | keyof T, direction?: `${Model.OrderDirection}`): DecoratorFunction<T> {
+export function OrderBy<T>(options: OrderByOptions[]): DecoratorFunction<T>
+export function OrderBy<T>(path: (keyof T) & string, direction?: OrderByDirection): DecoratorFunction<T>
+export function OrderBy<T>(options: OrderByOptions | OrderByOptions[] | ((keyof T) & string), 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) as Model.OrderDirection
+		const normalize = (path: string[], direction?: OrderByDirection): Model.OrderBy => ({
+			path,
+			direction: (direction ?? Model.OrderDirection.asc) as Model.OrderDirection,
+		})
+		const orderBy = ((): Model.OrderBy[] => {
+			if (Array.isArray(options)) {
+				return options.map(it => normalize(it.path, it.direction))
+			}
+			if (typeof options === 'object') {
+				return [normalize(options.path, options.direction)]
+			}
+			return [normalize([options], direction)]
+		})()
 
+		if (entity.orderBy?.length) {
+			// eslint-disable-next-line no-console
+			console.warn(`DEPRECATED: The "order by" property for the entity ${entity.name} has already been defined. Using multiple decorators can lead to unexpected order. Please provide an array containing all the 'order by' items as an input.`)
+		}
 
 		return {
 			...entity,
-			orderBy: [...(entity.orderBy ?? []), { path, direction: dir }],
+			orderBy: [...(entity.orderBy ?? []), ...orderBy],
 		}
 	})
 }

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

@@ -0,0 +1,88 @@
+import { Model } from '@contember/schema'
+import { assert, describe, expect, test, vi } from 'vitest'
+import { c, createSchema } from '../../../src'
+
+namespace OrderByModel {
+	@c.OrderBy('title')
+	export class Entity1 {
+		title = c.stringColumn()
+	}
+
+	@c.OrderBy('title', 'ascNullsFirst')
+	export class Entity2 {
+		title = c.stringColumn()
+	}
+
+	@c.OrderBy({ path: ['title'], direction: 'descNullsLast' })
+	export class Entity3 {
+		title = c.stringColumn()
+	}
+
+	@c.OrderBy([
+		{ path: ['order'], direction: 'asc' },
+		{ path: ['title'], direction: 'descNullsLast' },
+	])
+	export class Entity4 {
+		order = c.intColumn()
+		title = c.stringColumn()
+	}
+}
+
+namespace LegacyOrderBy {
+	@c.OrderBy('order')
+	@c.OrderBy('title')
+	export class Entity5 {
+		order = c.intColumn()
+		title = c.stringColumn()
+	}
+}
+
+describe('order by', () => {
+
+	test('simple order by', () => {
+		const schema = createSchema(OrderByModel)
+
+		assert.deepEqual(schema.model.entities.Entity1.orderBy, [{ path: ['title'], direction: Model.OrderDirection.asc }])
+	})
+
+	test('custom direction', () => {
+		const schema = createSchema(OrderByModel)
+
+		assert.deepEqual(schema.model.entities.Entity2.orderBy, [{ path: ['title'], direction: Model.OrderDirection.ascNullsFirst }])
+	})
+
+	test('object input order by', () => {
+		const schema = createSchema(OrderByModel)
+
+		assert.deepEqual(schema.model.entities.Entity3.orderBy, [{ path: ['title'], direction: Model.OrderDirection.descNullsLast }])
+	})
+
+	test('multiple order by', () => {
+		const schema = createSchema(OrderByModel)
+
+		assert.deepEqual(schema.model.entities.Entity4.orderBy, [
+			{ path: ['order'], direction: Model.OrderDirection.asc },
+			{ path: ['title'], direction: Model.OrderDirection.descNullsLast },
+		])
+	})
+
+	test('deprecated orderBy', () => {
+
+		const consoleMock = vi.spyOn(console, 'warn').mockImplementation(() => {
+		})
+
+		const schema = createSchema(LegacyOrderBy)
+
+
+		assert.deepEqual(schema.model.entities.Entity5.orderBy, [
+			{ path: ['title'], direction: Model.OrderDirection.asc },
+			{ path: ['order'], direction: Model.OrderDirection.asc },
+		])
+
+		expect(consoleMock).toHaveBeenCalledOnce()
+		expect(consoleMock).toHaveBeenLastCalledWith('DEPRECATED: The "order by" property for the entity Entity5 has already been defined. Using multiple decorators can lead to unexpected order. Please provide an array containing all the \'order by\' items as an input.')
+
+		consoleMock.mockReset()
+	})
+})
+

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

@@ -553,3 +553,27 @@ namespace InvalidModel {
 test('invalid column', () => {
 	expect(() => createSchema(InvalidModel)).toThrow('Field "bar" does not exist on entity "Book" in read ACL definition.')
 })
+
+
+namespace ExplicitIdPredicate {
+	export const publicRole = c.createRole('public')
+
+	@c.Allow(publicRole, { read: ['id'] })
+	export class Book {
+		title = c.stringColumn()
+	}
+}
+
+test('explicit ID predicate', () => {
+	const schema = createSchema(ExplicitIdPredicate)
+	expect(schema.acl.roles.public.entities.Book).toMatchInlineSnapshot(`
+		{
+		  "operations": {
+		    "read": {
+		      "id": true,
+		    },
+		  },
+		  "predicates": {},
+		}
+	`)
+})