@contember/engine-content-api 2.0.1 → 2.1.0-alpha.2

package/src/schema/GraphQlSchemaBuilderFactory.ts

@@ -29,6 +29,7 @@ import { PaginatedHasManyFieldProvider } from '../extensions/paginatedHasMany/Pa
 import { PaginatedHasManyFieldProviderVisitor } from '../extensions/paginatedHasMany/PaginatedHasManyFieldProviderVisitor'
 import { Builder } from '@contember/dic'
 import { ConnectOrCreateRelationInputProvider } from './mutations/ConnectOrCreateRelationInputProvider'
+import { RefreshViewMutationProvider } from './RefreshViewMutationProvider'
 
 export class GraphQlSchemaBuilderFactory {
 	constructor() {}
@@ -101,8 +102,10 @@ export class GraphQlSchemaBuilderFactory {
 				new MutationProvider(authorizator, whereTypeProvider, entityTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider))
 			.addService('validationQueriesProvider', ({ whereTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider }) =>
 				new ValidationQueriesProvider(whereTypeProvider, createEntityInputProvider, updateEntityInputProvider, resultSchemaTypeProvider))
-			.addService('graphQlSchemaBuilder', ({ schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider }) =>
-				new GraphQlSchemaBuilder(schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider))
+			.addService('refreshViewMutationProvider', ({ schema, authorizator }) =>
+				new RefreshViewMutationProvider(schema, authorizator))
+			.addService('graphQlSchemaBuilder', ({ schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider, refreshViewMutationProvider }) =>
+				new GraphQlSchemaBuilder(schema, queryProvider, validationQueriesProvider, mutationProvider, resultSchemaTypeProvider, refreshViewMutationProvider))
 			.setupService('createEntityInputProvider', (it, { createEntityInputProviderAccessor }) => {
 				createEntityInputProviderAccessor.set(it)
 			})

package/src/schema/OrderByTypeProvider.ts

@@ -57,7 +57,12 @@ export class OrderByTypeProvider {
 			}
 
 			const field = acceptFieldVisitor(this.schema, name, fieldName, {
-				visitColumn: () => ({ type: this.orderDirectionEnum }),
+				visitColumn: ({ column }) => {
+					if (column.list) {
+						return undefined
+					}
+					return ({ type: this.orderDirectionEnum })
+				},
 				visitHasOne: ({ relation }) => ({ type: this.getEntityOrderByType(relation.target) }),
 				visitHasMany: () => undefined,
 			} as Model.FieldVisitor<GraphQLInputFieldConfig | undefined>)

package/src/schema/RefreshViewMutationProvider.ts

@@ -0,0 +1,40 @@
+import { Model } from '@contember/schema'
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFieldConfig, GraphQLObjectType } from 'graphql'
+import { Context } from '../types'
+import { Authorizator } from '../acl'
+
+export class RefreshViewMutationProvider {
+	constructor(
+		private readonly schema: Model.Schema,
+		private readonly authorizator: Authorizator,
+	) {
+	}
+	getMutation(): GraphQLFieldConfig<any, Context, any> | undefined {
+		const materializedViews = Object.values(this.schema.entities)
+			.filter(it => it.view?.materialized)
+			.filter(it => this.authorizator.isRefreshMaterializedViewAllowed(it.name))
+		if (materializedViews.length === 0) {
+			return undefined
+		}
+
+		const materializedViewsEnum = new GraphQLEnumType({
+			name: '_MaterializedView',
+			values: Object.fromEntries(materializedViews.map(it => [it.name, { value: it.name }])),
+		})
+
+		return {
+			type: new GraphQLObjectType({
+				name: 'RefreshMaterializedViewResponse',
+				fields: {
+					ok: { type: GraphQLBoolean },
+				},
+			}),
+			args: {
+				name: { type: materializedViewsEnum },
+			},
+			resolve: async (parent, args, context) => {
+				return await context.executionContainer.refreshViewResolver.resolve(args.name)
+			},
+		}
+	}
+}

package/src/schema/WhereTypeProvider.ts

@@ -83,7 +83,7 @@ export class WhereTypeProvider {
 						}
 						return { type: uniqueWhere }
 					},
-					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column) }),
+					visitColumn: ({ column }) => ({ type: this.columnTypeResolver.getType(column)[0] }),
 				})
 			}
 		}

package/src/schema/entities/FieldTypeVisitor.ts

@@ -14,16 +14,16 @@ export class FieldTypeVisitor implements Model.ColumnVisitor<GraphQLOutputType>,
 	}
 
 	public visitColumn({ column, entity }: Model.ColumnContext): GraphQLOutputType {
-		const basicType = this.columnTypeResolver.getType(column)
+		const [type] = this.columnTypeResolver.getType(column)
 		const fieldPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, column.name)
 		const idPredicate = this.authorizator.getFieldPredicate(Acl.Operation.read, entity.name, entity.primary)
 		if (!fieldPredicate || !idPredicate) {
 			throw new ImplementationException()
 		}
 		if (!column.nullable && (fieldPredicate === true || fieldPredicate === idPredicate)) {
-			return new GraphQLNonNull(basicType)
+			return new GraphQLNonNull(type)
 		}
-		return basicType
+		return type
 	}
 
 	public visitHasMany({ relation }: Model.AnyHasManyRelationContext): GraphQLOutputType {

package/src/schema/mutations/CreateEntityInputFieldVisitor.ts

@@ -22,7 +22,7 @@ export class CreateEntityInputFieldVisitor implements
 		if (this.authorizator.getFieldPermissions(Acl.Operation.create, entity.name, column.name) === 'no') {
 			return undefined
 		}
-		const type = this.columnTypeResolver.getType(column)
+		const [type] = this.columnTypeResolver.getType(column)
 		return { type }
 	}
 

package/src/schema/mutations/UpdateEntityInputFieldVisitor.ts

@@ -21,7 +21,7 @@ export class UpdateEntityInputFieldVisitor implements
 		if (this.authorizator.getFieldPermissions(Acl.Operation.update, entity.name, column.name) === 'no') {
 			return undefined
 		}
-		const type = this.columnTypeResolver.getType(column)
+		const [type] = this.columnTypeResolver.getType(column)
 		return { type }
 	}
 

package/src/utils/viewComputedId.ts

@@ -0,0 +1,23 @@
+import crypto from 'node:crypto'
+
+export const viewComputedId = (inputs: (string)[]): string => {
+	let uuidBytes: Buffer
+	uuidBytes = crypto.createHash('md5').update(inputs.join('\x00')).digest()
+
+	// Set the version (v8) in the high nibble of byte 6.
+	uuidBytes[6] = (uuidBytes[6] & 0x0f) | 0x80 // 0x80 = 1000 0000 (version 8)
+
+	// Set the variant (RFC 4122) in byte 8.
+	uuidBytes[8] = (uuidBytes[8] & 0x3f) | 0x80
+
+	return formatUUID(uuidBytes)
+}
+
+const formatUUID = (buf: Buffer): string => {
+	const hex = buf.toString('hex')
+	return hex.substring(0, 8)
+		+ '-' + hex.substring(8, 12)
+		+ '-' + hex.substring(12, 16)
+		+ '-' + hex.substring(16, 20)
+		+ '-' + hex.substring(20)
+}

package/tests/cases/integration/graphQlSchema/graphQlSchemaBuilder.test.ts

@@ -29,7 +29,7 @@ const testSchema = async (test: Test) => {
 	const schema = schemaResult instanceof SchemaBuilder ? schemaResult.buildSchema() : schemaResult
 	const schemaWithAcl = { ...schema, acl: { roles: {}, variables: {} } }
 	const permissions = test.permissions(schemaWithAcl)
-	const authorizator = new Authorizator(permissions, false)
+	const authorizator = new Authorizator(permissions, false, false)
 	const graphQlSchemaBuilder = schemaFactory.create(schemaWithAcl, authorizator)
 	const graphQlSchema = graphQlSchemaBuilder.build()
 
@@ -61,7 +61,26 @@ const testSchema = async (test: Test) => {
 	}
 }
 describe('GraphQL schema builder', () => {
-
+	it('column types', async () => {
+		await testSchema({
+			schema: () => createSchema({
+				Columns: class Columns {
+					string = c.stringColumn()
+					int = c.intColumn()
+					float = c.doubleColumn()
+					boolean = c.boolColumn()
+					date = c.dateColumn()
+					dateTime = c.dateTimeColumn()
+					json = c.jsonColumn()
+					uuid = c.uuidColumn()
+					time = c.timeColumn()
+					enum = c.enumColumn(c.createEnum('a', 'b', 'c'))
+				},
+			}).model,
+			permissions: schema => new AllowAllPermissionFactory().create(schema),
+			graphQlSchemaFile: 'schema-column-types.gql',
+		})
+	})
 
 	it('basic schema', async () => {
 		await testSchema({
@@ -402,6 +421,23 @@ describe('GraphQL schema builder', () => {
 			graphQlSchemaFile: 'schema-no-root-ops.gql',
 		})
 	})
+
+
+	it('array', async () => {
+		const schema = createSchema({
+			Foo: class Foo {
+				stringArrayValue = c.stringColumn().list()
+				enumArrayValue = c.enumColumn(c.createEnum('a', 'b', 'c')).list()
+				intArrayValue = c.intColumn().list()
+			},
+		})
+
+		await testSchema({
+			schema: () => schema.model,
+			permissions: schema => new AllowAllPermissionFactory().create(schema),
+			graphQlSchemaFile: 'schema-array.gql',
+		})
+	})
 })
 
 namespace ViewEntity {

package/tests/cases/integration/graphQlSchema/schema-aliased-type.gql

@@ -70,6 +70,12 @@ input AuthorNameCondition {
   lte: AuthorName
   gt: AuthorName
   gte: AuthorName
+  contains: String
+  startsWith: String
+  endsWith: String
+  containsCI: String
+  startsWithCI: String
+  endsWithCI: String
 }
 
 input AuthorOrderBy {

package/tests/cases/integration/graphQlSchema/schema-array.gql

@@ -0,0 +1,257 @@
+type Query {
+  getFoo(by: FooUniqueWhere!, filter: FooWhere): Foo
+  listFoo(filter: FooWhere, orderBy: [FooOrderBy!], offset: Int, limit: Int): [Foo!]!
+  paginateFoo(filter: FooWhere, orderBy: [FooOrderBy!], skip: Int, first: Int): FooConnection!
+  validateCreateFoo(data: FooCreateInput!): _ValidationResult!
+  validateUpdateFoo(by: FooUniqueWhere!, data: FooUpdateInput!): _ValidationResult!
+  transaction: QueryTransaction
+  _info: Info
+}
+
+type Foo {
+  _meta: FooMeta
+  id: UUID!
+  stringArrayValue: [String!]
+  enumArrayValue: [FooEnumArrayValue!]
+  intArrayValue: [Int!]
+}
+
+type FooMeta {
+  id: FieldMeta
+  stringArrayValue: FieldMeta
+  enumArrayValue: FieldMeta
+  intArrayValue: FieldMeta
+}
+
+type FieldMeta {
+  readable: Boolean
+  updatable: Boolean
+}
+
+scalar UUID
+
+enum FooEnumArrayValue {
+  a
+  b
+  c
+}
+
+input FooUniqueWhere {
+  id: UUID
+}
+
+input FooWhere {
+  id: UUIDCondition
+  stringArrayValue: StringListCondition
+  enumArrayValue: FooEnumArrayValueEnumListCondition
+  intArrayValue: IntListCondition
+  and: [FooWhere]
+  or: [FooWhere]
+  not: FooWhere
+}
+
+input UUIDCondition {
+  and: [UUIDCondition!]
+  or: [UUIDCondition!]
+  not: UUIDCondition
+  null: Boolean
+  isNull: Boolean
+  eq: UUID
+  notEq: UUID
+  in: [UUID!]
+  notIn: [UUID!]
+  lt: UUID
+  lte: UUID
+  gt: UUID
+  gte: UUID
+}
+
+input StringListCondition {
+  and: [StringListCondition!]
+  or: [StringListCondition!]
+  not: StringListCondition
+  null: Boolean
+  isNull: Boolean
+  minLength: Int
+  maxLength: Int
+  includes: String
+}
+
+input FooEnumArrayValueEnumListCondition {
+  and: [FooEnumArrayValueEnumListCondition!]
+  or: [FooEnumArrayValueEnumListCondition!]
+  not: FooEnumArrayValueEnumListCondition
+  null: Boolean
+  isNull: Boolean
+  minLength: Int
+  maxLength: Int
+  includes: FooEnumArrayValue
+}
+
+input IntListCondition {
+  and: [IntListCondition!]
+  or: [IntListCondition!]
+  not: IntListCondition
+  null: Boolean
+  isNull: Boolean
+  minLength: Int
+  maxLength: Int
+  includes: Int
+}
+
+input FooOrderBy {
+  _random: Boolean
+  _randomSeeded: Int
+  id: OrderDirection
+}
+
+enum OrderDirection {
+  asc
+  desc
+  ascNullsFirst
+  descNullsLast
+}
+
+type FooConnection {
+  pageInfo: PageInfo!
+  edges: [FooEdge!]!
+}
+
+type PageInfo {
+  totalCount: Int!
+}
+
+type FooEdge {
+  node: Foo!
+}
+
+type _ValidationResult {
+  valid: Boolean!
+  errors: [_ValidationError!]!
+}
+
+type _ValidationError {
+  path: [_PathFragment!]!
+  message: _ValidationMessage!
+}
+
+union _PathFragment = _FieldPathFragment | _IndexPathFragment
+
+type _FieldPathFragment {
+  field: String!
+}
+
+type _IndexPathFragment {
+  index: Int!
+  alias: String
+}
+
+type _ValidationMessage {
+  text: String!
+}
+
+input FooCreateInput {
+  stringArrayValue: [String!]
+  enumArrayValue: [FooEnumArrayValue!]
+  intArrayValue: [Int!]
+  _dummy_field_: Boolean
+}
+
+input FooUpdateInput {
+  stringArrayValue: [String!]
+  enumArrayValue: [FooEnumArrayValue!]
+  intArrayValue: [Int!]
+  _dummy_field_: Boolean
+}
+
+type QueryTransaction {
+  getFoo(by: FooUniqueWhere!, filter: FooWhere): Foo
+  listFoo(filter: FooWhere, orderBy: [FooOrderBy!], offset: Int, limit: Int): [Foo!]!
+  paginateFoo(filter: FooWhere, orderBy: [FooOrderBy!], skip: Int, first: Int): FooConnection!
+  validateCreateFoo(data: FooCreateInput!): _ValidationResult!
+  validateUpdateFoo(by: FooUniqueWhere!, data: FooUpdateInput!): _ValidationResult!
+}
+
+type Info {
+  description: String
+}
+
+type Mutation {
+  createFoo(data: FooCreateInput!): FooCreateResult!
+  deleteFoo(by: FooUniqueWhere!, filter: FooWhere): FooDeleteResult!
+  updateFoo(by: FooUniqueWhere!, filter: FooWhere, data: FooUpdateInput!): FooUpdateResult!
+  upsertFoo(by: FooUniqueWhere!, filter: FooWhere, update: FooUpdateInput!, create: FooCreateInput!): FooUpsertResult!
+  transaction(options: MutationTransactionOptions): MutationTransaction!
+  query: Query!
+}
+
+type FooCreateResult implements MutationResult {
+  ok: Boolean!
+  errorMessage: String
+  errors: [_MutationError!]!
+  node: Foo
+  validation: _ValidationResult!
+}
+
+interface MutationResult {
+  ok: Boolean!
+  errorMessage: String
+  errors: [_MutationError!]!
+}
+
+type _MutationError {
+  path: [_PathFragment!]! @deprecated(reason: "Use `paths`.")
+  paths: [[_PathFragment!]!]!
+  type: _MutationErrorType!
+  message: String
+}
+
+enum _MutationErrorType {
+  NotNullConstraintViolation
+  UniqueConstraintViolation
+  ForeignKeyConstraintViolation
+  NotFoundOrDenied
+  NonUniqueWhereInput
+  InvalidDataInput
+  SqlError
+}
+
+type FooDeleteResult implements MutationResult {
+  ok: Boolean!
+  errorMessage: String
+  errors: [_MutationError!]!
+  node: Foo
+}
+
+type FooUpdateResult implements MutationResult {
+  ok: Boolean!
+  errorMessage: String
+  errors: [_MutationError!]!
+  node: Foo
+  validation: _ValidationResult!
+}
+
+type FooUpsertResult implements MutationResult {
+  ok: Boolean!
+  errorMessage: String
+  errors: [_MutationError!]!
+  node: Foo
+  validation: _ValidationResult!
+}
+
+type MutationTransaction {
+  ok: Boolean!
+  errorMessage: String
+  errors: [_MutationError!]!
+  validation: _ValidationResult!
+  createFoo(data: FooCreateInput!): FooCreateResult!
+  deleteFoo(by: FooUniqueWhere!, filter: FooWhere): FooDeleteResult!
+  updateFoo(by: FooUniqueWhere!, filter: FooWhere, data: FooUpdateInput!): FooUpdateResult!
+  upsertFoo(by: FooUniqueWhere!, filter: FooWhere, update: FooUpdateInput!, create: FooCreateInput!): FooUpsertResult!
+  query: Query
+}
+
+input MutationTransactionOptions {
+  deferForeignKeyConstraints: Boolean
+  deferUniqueConstraints: Boolean
+}