@contember/bindx 0.1.5 → 0.1.9

package/src/adapter/ContemberAdapter.ts

@@ -1,19 +1,25 @@
-import { GraphQlClient } from '@contember/graphql-client'
 import {
 	ContentClient,
-	ContentQueryBuilder,
-	ContentEntitySelection,
-	SchemaNames,
-	ContentQuery,
-	type EntitySelectionManyArgs,
-	type EntitySelectionOneArgs,
-	type EntitySelectionColumnArgs,
-	type ContentClientInput,
-} from '@contember/client-content'
-import { type Input } from '@contember/schema'
+	type ContentClientOptions,
+	ContentOperation,
+	type ContentQuery,
+	querySpecToGraphQl,
+	type QuerySpecContext,
+	buildGetArgs,
+	buildListArgs,
+	buildCreateArgs,
+	buildUpdateArgs,
+	buildDeleteArgs,
+	buildMutationSelection,
+	mutationFragments,
+	unwrapPaginateResult,
+} from '@contember/bindx-client'
+import type { GraphQlClient } from '@contember/graphql-client'
 import type { QuerySpec, QueryFieldSpec } from '../selection/buildQuery.js'
 import type { BackendAdapter, Query, QueryResult, QueryOptions, GetQuery, ListQuery, PersistResult, CreateResult, DeleteResult } from './types.js'
 import type { ContemberMutationResult } from '../errors/pathMapper.js'
+import type { SchemaRegistry } from '../schema/SchemaRegistry.js'
+import { GraphQlField } from '@contember/graphql-builder'
 
 /**
  * Options for ContemberAdapter
@@ -21,19 +27,19 @@ import type { ContemberMutationResult } from '../errors/pathMapper.js'
 export interface ContemberAdapterOptions {
 	/** GraphQL client instance */
 	client: GraphQlClient
-	/** Contember schema names for query building */
-	schema: SchemaNames
+	/** Schema registry for relation target resolution */
+	schemaRegistry: SchemaRegistry
 }
 
 /**
  * Backend adapter for Contember Content API.
- * Uses @contember/client-content for type-safe GraphQL operations.
+ * Uses @contember/bindx-client for GraphQL operations.
  */
 export class ContemberAdapter implements BackendAdapter {
 
 	constructor(
 		private readonly contentClient: ContentClient,
-		private readonly queryBuilder: ContentQueryBuilder,
+		private readonly schemaRegistry: SchemaRegistry,
 	) {
 	}
 
@@ -59,34 +65,52 @@ export class ContemberAdapter implements BackendAdapter {
 			signal: options?.signal,
 		})
 
-		// Map results back to QueryResult array
-		// Content client transforms already unwrap paginateRelation → flat arrays
+		// Map results back to QueryResult array, unwrapping paginate format
 		return queries.map((q, i) => {
 			const key = `q${i}`
 			const data = (results as Record<string, unknown>)[key]
 
 			if (q.type === 'get') {
-				return { type: 'get' as const, data: data as Record<string, unknown> | null }
+				const unwrapped = data ? unwrapPaginateFields(data as Record<string, unknown>, q.spec) : null
+				return { type: 'get' as const, data: unwrapped }
 			} else {
-				return { type: 'list' as const, data: (data ?? []) as readonly Record<string, unknown>[] }
+				const items = (data ?? []) as readonly Record<string, unknown>[]
+				return { type: 'list' as const, data: items.map(item => unwrapPaginateFields(item, q.spec)) }
 			}
 		})
 	}
 
 	private buildGetQuery(query: GetQuery): ContentQuery<unknown> {
-		const selection = this.buildEntitySelection(query.spec)
-		return this.queryBuilder.get(query.entityType, { by: query.by }, selection)
+		const context = this.createContext(query.entityType)
+		const selectionSet = querySpecToGraphQl(query.spec, context)
+		const args = buildGetArgs(query.entityType, { by: query.by })
+
+		return new ContentOperation(
+			'query',
+			`get${query.entityType}`,
+			args,
+			selectionSet,
+			value => value,
+		)
 	}
 
 	private buildListQuery(query: ListQuery): ContentQuery<unknown> {
-		const selection = this.buildEntitySelection(query.spec)
-		const args: ContentClientInput.AnyListQueryInput = {
-			filter: query.filter as Input.OptionalWhere | undefined,
-			orderBy: query.orderBy as ContentClientInput.AnyOrderBy | undefined,
+		const context = this.createContext(query.entityType)
+		const selectionSet = querySpecToGraphQl(query.spec, context)
+		const args = buildListArgs(query.entityType, {
+			filter: query.filter,
+			orderBy: query.orderBy as unknown[],
 			limit: query.limit,
 			offset: query.offset,
-		}
-		return this.queryBuilder.list(query.entityType, args, selection)
+		})
+
+		return new ContentOperation(
+			'query',
+			`list${query.entityType}`,
+			args,
+			selectionSet,
+			value => value,
+		)
 	}
 
 	async persist(
@@ -94,84 +118,117 @@ export class ContemberAdapter implements BackendAdapter {
 		id: string,
 		changes: Record<string, unknown>,
 	): Promise<PersistResult> {
-		const mutation = this.queryBuilder.update(entityType, {
-			by: { id },
-			data: changes as Input.UpdateDataInput,
-		})
+		const args = buildUpdateArgs(entityType, { by: { id }, data: changes })
+		const selectionSet = buildMutationSelection('update')
 
-		const result = await this.contentClient.mutate(mutation)
+		const mutation = new ContentOperation(
+			'mutation',
+			`update${entityType}`,
+			args,
+			selectionSet,
+			value => value as { ok: boolean; errorMessage: string | null; errors: unknown[]; validation: unknown },
+		)
 
-		if (!result.ok) {
-			return {
-				ok: false,
-				errorMessage: result.errorMessage ?? `Failed to update ${entityType}:${id}`,
-				mutationResult: this.toMutationResult(result),
+		try {
+			const result = await this.contentClient.mutate(mutation)
+			return { ok: true }
+		} catch (e) {
+			if (e instanceof Error && 'result' in e) {
+				const mutResult = (e as { result: Record<string, unknown> }).result
+				return {
+					ok: false,
+					errorMessage: (mutResult['errorMessage'] as string | null) ?? `Failed to update ${entityType}:${id}`,
+					mutationResult: this.toMutationResult(mutResult),
+				}
 			}
+			throw e
 		}
-
-		return { ok: true }
 	}
 
 	async create(
 		entityType: string,
 		data: Record<string, unknown>,
 	): Promise<CreateResult> {
-		// Build selection to return created entity
-		const selection = (s: ContentEntitySelection) => s.$('id')
+		const args = buildCreateArgs(entityType, { data })
+		// Select id on created node
+		const nodeSelection = [new GraphQlField(null, 'id')]
+		const selectionSet = buildMutationSelection('create', nodeSelection)
 
-		const mutation = this.queryBuilder.create(entityType, { data: data as Input.CreateDataInput }, selection)
-		const result = await this.contentClient.mutate(mutation)
+		const mutation = new ContentOperation(
+			'mutation',
+			`create${entityType}`,
+			args,
+			selectionSet,
+			value => value as { ok: boolean; errorMessage: string | null; errors: unknown[]; validation: unknown; node: unknown },
+		)
 
-		if (!result.ok) {
+		try {
+			const result = await this.contentClient.mutate(mutation)
+			const typedResult = result as { node: Record<string, unknown> | null }
 			return {
-				ok: false,
-				errorMessage: result.errorMessage ?? `Failed to create ${entityType}`,
-				mutationResult: this.toMutationResult(result),
+				ok: true,
+				data: typedResult.node as Record<string, unknown>,
 			}
-		}
-
-		return {
-			ok: true,
-			data: result.node as Record<string, unknown>,
+		} catch (e) {
+			if (e instanceof Error && 'result' in e) {
+				const mutResult = (e as { result: Record<string, unknown> }).result
+				return {
+					ok: false,
+					errorMessage: (mutResult['errorMessage'] as string | null) ?? `Failed to create ${entityType}`,
+					mutationResult: this.toMutationResult(mutResult),
+				}
+			}
+			throw e
 		}
 	}
 
 	async delete(entityType: string, id: string): Promise<DeleteResult> {
-		const mutation = this.queryBuilder.delete(entityType, { by: { id } })
-		const result = await this.contentClient.mutate(mutation)
+		const args = buildDeleteArgs(entityType, { by: { id } })
+		const selectionSet = buildMutationSelection('delete')
 
-		if (!result.ok) {
-			return {
-				ok: false,
-				errorMessage: result.errorMessage ?? `Failed to delete ${entityType}:${id}`,
-				mutationResult: this.toMutationResult(result),
+		const mutation = new ContentOperation(
+			'mutation',
+			`delete${entityType}`,
+			args,
+			selectionSet,
+			value => value as { ok: boolean; errorMessage: string | null; errors: unknown[] },
+		)
+
+		try {
+			const result = await this.contentClient.mutate(mutation)
+			return { ok: true }
+		} catch (e) {
+			if (e instanceof Error && 'result' in e) {
+				const mutResult = (e as { result: Record<string, unknown> }).result
+				return {
+					ok: false,
+					errorMessage: (mutResult['errorMessage'] as string | null) ?? `Failed to delete ${entityType}:${id}`,
+					mutationResult: this.toMutationResult(mutResult),
+				}
 			}
+			throw e
 		}
-
-		return { ok: true }
 	}
 
 	/**
-	 * Converts Contember mutation result to our ContemberMutationResult type.
+	 * Converts raw mutation result to ContemberMutationResult type.
 	 */
-	private toMutationResult(result: {
-		ok: boolean
-		errorMessage: string | null
-		errors: Array<{ paths: Array<Array<{ field: string } | { index: number; alias: string | null }>>; message: string; type: string }>
-		validation: { valid: boolean; errors: Array<{ path: Array<{ field: string } | { index: number; alias: string | null }>; message: { text: string } }> }
-	}): ContemberMutationResult {
+	private toMutationResult(result: Record<string, unknown>): ContemberMutationResult {
+		const errors = (result['errors'] as Array<{ paths: unknown; message: string; type: string }>) ?? []
+		const validation = result['validation'] as { valid: boolean; errors: Array<{ path: unknown; message: { text: string } }> } | undefined
+
 		return {
-			ok: result.ok,
-			errorMessage: result.errorMessage,
-			errors: result.errors.map(e => ({
-				paths: e.paths,
+			ok: result['ok'] as boolean,
+			errorMessage: result['errorMessage'] as string | null,
+			errors: errors.map(e => ({
+				paths: e.paths as Array<Array<{ field: string } | { index: number; alias: string | null }>>,
 				message: e.message,
 				type: e.type,
 			})),
 			validation: {
-				valid: result.validation.valid,
-				errors: result.validation.errors.map(e => ({
-					path: e.path,
+				valid: validation?.valid ?? true,
+				errors: (validation?.errors ?? []).map(e => ({
+					path: e.path as Array<{ field: string } | { index: number; alias: string | null }>,
 					message: { text: e.message.text },
 				})),
 			},
@@ -179,61 +236,74 @@ export class ContemberAdapter implements BackendAdapter {
 	}
 
 	/**
-	 * Builds ContentEntitySelection from QuerySpec
+	 * Creates a QuerySpecContext for an entity, wiring in SchemaRegistry for relation target resolution.
 	 */
-	private buildEntitySelection(
-		query: QuerySpec,
-	): (selection: ContentEntitySelection) => ContentEntitySelection {
-		return (selection: ContentEntitySelection) => {
-			return this.applyFieldsToSelection(selection, query.fields)
+	private createContext(entityName: string): QuerySpecContext {
+		return {
+			entityName,
+			resolveRelationTarget: (entity, field) => this.schemaRegistry.getRelationTarget(entity, field),
 		}
 	}
+}
 
-	/**
-	 * Recursively applies QueryFieldSpec[] to ContentEntitySelection
-	 */
-	private applyFieldsToSelection(
-		selection: ContentEntitySelection,
-		fields: QueryFieldSpec[],
-	): ContentEntitySelection {
-		let result = selection
-
-		for (const field of fields) {
-			const fieldName = field.sourcePath[0]
-			if (!fieldName) continue
-
-			if (field.nested) {
-				// Relation field (has-one or has-many)
-				const nestedCallback = (s: ContentEntitySelection) =>
-					this.applyFieldsToSelection(s, field.nested!.fields)
-
-				if (field.isArray) {
-					// has-many relation — always uses paginateRelation
-					const manyArgs: EntitySelectionManyArgs = {
-						...(field.name !== fieldName ? { as: field.name } : undefined),
-						...(field.filter !== undefined ? { filter: field.filter as Input.OptionalWhere } : undefined),
-						...(field.orderBy !== undefined ? { orderBy: field.orderBy as ContentClientInput.AnyOrderBy } : undefined),
-						...(field.limit !== undefined ? { limit: field.limit } : undefined),
-						...(field.offset !== undefined ? { offset: field.offset } : undefined),
-						...(field.totalCount ? { totalCount: true } : undefined),
-					}
-
-					result = result.$(fieldName, manyArgs, nestedCallback)
-				} else {
-					// has-one relation
-					const oneArgs: EntitySelectionOneArgs = {
-						...(field.name !== fieldName ? { as: field.name } : undefined),
-					}
-					result = result.$(fieldName, oneArgs, nestedCallback)
-				}
+/**
+ * Recursively unwraps paginate connection format in entity data.
+ *
+ * The GraphQL layer uses `paginateFieldName { edges { node { ... } } }` for has-many relations,
+ * but the store expects flat arrays keyed by the original field name.
+ * This function uses the QuerySpec to identify which fields need unwrapping.
+ */
+function unwrapPaginateFields(data: Record<string, unknown>, spec: QuerySpec): Record<string, unknown> {
+	const result: Record<string, unknown> = {}
+
+	// Copy all fields from data first
+	const handledKeys = new Set<string>()
+
+	for (const field of spec.fields) {
+		const fieldName = field.sourcePath[0]
+		if (!fieldName) continue
+
+		if (field.isArray && field.nested) {
+			// Has-many field — look for paginate key or alias
+			const paginateKey = `paginate${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`
+			const alias = field.name !== fieldName ? field.name : null
+			const lookupKey = alias ?? paginateKey
+
+			const value = data[lookupKey]
+			handledKeys.add(lookupKey)
+
+			if (value && typeof value === 'object' && 'edges' in value) {
+				const connection = value as { edges: { node: unknown }[]; pageInfo?: { totalCount: number } }
+				const items = unwrapPaginateResult(connection, !!field.totalCount) as Record<string, unknown>[]
+				result[field.name] = items.map(item => unwrapPaginateFields(item, field.nested!))
 			} else {
-				// Scalar field
-				const columnArgs: EntitySelectionColumnArgs | undefined =
-					field.name !== fieldName ? { as: field.name } : undefined
-				result = result.$(fieldName, columnArgs)
+				result[field.name] = value
 			}
+		} else if (field.nested) {
+			// Has-one relation — recurse into nested
+			const lookupKey = field.name !== fieldName ? field.name : fieldName
+			const value = data[lookupKey]
+			handledKeys.add(lookupKey)
+
+			if (value && typeof value === 'object') {
+				result[field.name] = unwrapPaginateFields(value as Record<string, unknown>, field.nested)
+			} else {
+				result[field.name] = value
+			}
+		} else {
+			// Scalar field
+			const lookupKey = field.name !== fieldName ? field.name : fieldName
+			handledKeys.add(lookupKey)
+			result[field.name] = data[lookupKey]
 		}
+	}
 
-		return result
+	// Preserve any extra fields not in the spec (e.g. 'id' returned by API)
+	for (const key of Object.keys(data)) {
+		if (!handledKeys.has(key) && !(key in result)) {
+			result[key] = data[key]
+		}
 	}
+
+	return result
 }

package/src/brand/ComponentBrand.ts

@@ -1,28 +1 @@
-/**
- * ComponentBrand provides unique identity for each component created with createComponent.
- * Each instance has a unique runtime Symbol for brand validation.
- * The class structure itself provides nominal typing in TypeScript.
- */
-export class ComponentBrand {
-	/**
-	 * Private property to ensure nominal typing.
-	 * Each class instance is considered a unique type.
-	 */
-	private readonly __nominal = true
-
-	/**
-	 * Runtime symbol for brand validation.
-	 * Used to check that EntityRef includes required component brands.
-	 */
-	readonly brandSymbol: symbol
-
-	constructor(public readonly name: string) {
-		this.brandSymbol = Symbol(`component_${name}_${Math.random().toString(36).slice(2)}`)
-	}
-}
-
-/**
- * Type alias for any ComponentBrand.
- * Used as default/base type in generic constraints.
- */
-export type AnyBrand = ComponentBrand
+export { ComponentBrand, type AnyBrand } from '@contember/bindx-client'

package/src/contember/index.ts

@@ -6,12 +6,5 @@
 
 // Re-export unified MutationCollector from persistence
 export { MutationCollector, type EntityMutationResult } from '../persistence/MutationCollector.js'
-export { ContemberSchemaMutationAdapter } from '../persistence/ContemberSchemaMutationAdapter.js'
+export { ContemberSchemaMutationAdapter, type SchemaNames } from '../persistence/ContemberSchemaMutationAdapter.js'
 export type { MutationSchemaProvider } from '../persistence/MutationSchemaProvider.js'
-
-// Re-export commonly used types from @contember/client-content
-export type {
-	SchemaNames,
-	SchemaEntityNames,
-	ContentClientInput,
-} from '@contember/client-content'