@contember/bindx 0.1.5 → 0.1.8

package/src/schema/ContemberSchema.ts

@@ -1,132 +1,14 @@
-/**
- * Types matching the Contember API schema introspection format.
- * These types are compatible with binding-common's Schema.
- */
-
-export type SchemaColumnType = 'Bool' | 'Date' | 'DateTime' | 'Double' | 'Enum' | 'Integer' | 'String' | 'Uuid' | 'Json' | string
-
-export interface SchemaColumn {
-	__typename: '_Column'
-	name: string
-	nullable: boolean
-	type: SchemaColumnType
-	enumName: string | null
-	defaultValue: string | number | boolean | null
-}
-
-export interface SchemaRelationOrderBy {
-	path: string[]
-	direction: 'asc' | 'desc'
-}
-
-interface BaseRelation {
-	__typename: '_Relation'
-	name: string
-	nullable: boolean | null
-	onDelete: 'restrict' | 'cascade' | 'setNull' | null
-	orderBy: SchemaRelationOrderBy[] | null
-	orphanRemoval: boolean | null
-	targetEntity: string
-	type: 'OneHasOne' | 'OneHasMany' | 'ManyHasOne' | 'ManyHasMany'
-}
-
-export interface OwningRelation extends BaseRelation {
-	side: 'owning'
-	inversedBy: string | null
-	ownedBy?: never
-}
-
-export interface InverseRelation extends BaseRelation {
-	side: 'inverse'
-	ownedBy: string
-	inversedBy?: never
-}
-
-export type SchemaRelation = OwningRelation | InverseRelation
-
-export type SchemaField = SchemaColumn | SchemaRelation
-
-export interface SchemaEntity {
-	name: string
-	customPrimaryAllowed: boolean
-	fields: Map<string, SchemaField>
-	unique: { fields: Set<string> }[]
-}
-
-export interface SchemaEnum {
-	name: string
-	values: string[]
-}
-
-/**
- * Processed schema store with Maps for efficient lookup.
- * This is the format used internally after loading from API.
- */
-export interface ContemberSchemaStore {
-	entities: Map<string, SchemaEntity>
-	enums: Map<string, Set<string>>
-}
-
-/**
- * Raw schema format as returned by the Contember API.
- */
-export interface RawContemberSchema {
-	enums: { name: string; values: string[] }[]
-	entities: {
-		name: string
-		customPrimaryAllowed: boolean
-		fields: (SchemaColumn | (Omit<SchemaRelation, 'side'> & { side: 'owning' | 'inverse'; ownedBy?: string; inversedBy?: string | null }))[]
-		unique: { fields: string[] }[]
-	}[]
-}
-
-/**
- * Schema class compatible with binding-common's Schema.
- * Can be used directly or created from API response.
- */
-export class ContemberSchema {
-	constructor(private readonly store: ContemberSchemaStore) {}
-
-	getEntity(entityName: string): SchemaEntity | undefined {
-		return this.store.entities.get(entityName)
-	}
-
-	getEntityNames(): string[] {
-		return Array.from(this.store.entities.keys())
-	}
-
-	getEntityField(entityName: string, fieldName: string): SchemaField | undefined {
-		return this.store.entities.get(entityName)?.fields.get(fieldName)
-	}
-
-	getEnumValues(enumName: string): string[] | undefined {
-		const values = this.store.enums.get(enumName)
-		return values ? Array.from(values) : undefined
-	}
-
-	/**
-	 * Creates a ContemberSchema from raw API response.
-	 */
-	static fromRaw(raw: RawContemberSchema): ContemberSchema {
-		const enums = new Map<string, Set<string>>()
-		for (const { name, values } of raw.enums) {
-			enums.set(name, new Set(values))
-		}
-
-		const entities = new Map<string, SchemaEntity>()
-		for (const entity of raw.entities) {
-			const fields = new Map<string, SchemaField>()
-			for (const field of entity.fields) {
-				fields.set(field.name, field as SchemaField)
-			}
-			entities.set(entity.name, {
-				name: entity.name,
-				customPrimaryAllowed: entity.customPrimaryAllowed,
-				fields,
-				unique: entity.unique.map(u => ({ fields: new Set(u.fields) })),
-			})
-		}
-
-		return new ContemberSchema({ entities, enums })
-	}
-}
+export {
+	ContemberSchema,
+	type SchemaColumnType,
+	type SchemaColumn,
+	type SchemaRelationOrderBy,
+	type OwningRelation,
+	type InverseRelation,
+	type SchemaRelation,
+	type SchemaField,
+	type SchemaEntity,
+	type SchemaEnum,
+	type ContemberSchemaStore,
+	type RawContemberSchema,
+} from '@contember/bindx-client'

package/src/schema/SchemaLoader.ts

@@ -1,93 +1 @@
-/**
- * Loads schema from Contember Content API via GraphQL introspection.
- */
-
-import { ContemberSchema, type RawContemberSchema } from './ContemberSchema.js'
-
-export interface SchemaLoaderClient {
-	execute<T>(query: string, options?: unknown): Promise<T>
-	apiUrl?: string
-}
-
-const SCHEMA_QUERY = `query {
-  schema {
-    enums {
-      name
-      values
-    }
-    entities {
-      name
-      customPrimaryAllowed
-      unique {
-        fields
-      }
-      fields {
-        __typename
-        name
-        type
-        nullable
-        ... on _Column {
-          enumName
-          defaultValue
-        }
-        ... on _Relation {
-          side
-          targetEntity
-          ownedBy
-          inversedBy
-          onDelete
-          orphanRemoval
-          orderBy {
-            path
-            direction
-          }
-        }
-      }
-    }
-  }
-}`
-
-/**
- * Loads and caches schema from Contember Content API.
- * Instance-level cache avoids cross-tenant collisions and test pollution.
- */
-export class SchemaLoader {
-	private readonly cache = new Map<string, Promise<ContemberSchema>>()
-
-	/**
-	 * Loads schema from the API, with caching per API URL.
-	 */
-	async loadSchema(
-		client: SchemaLoaderClient,
-		options?: unknown,
-	): Promise<ContemberSchema> {
-		const cacheKey = client.apiUrl ?? 'default'
-
-		const existing = this.cache.get(cacheKey)
-		if (existing) {
-			return existing
-		}
-
-		const promise = (async () => {
-			const response = await client.execute<{ schema: RawContemberSchema }>(SCHEMA_QUERY, options)
-			return ContemberSchema.fromRaw(response.schema)
-		})()
-
-		this.cache.set(cacheKey, promise)
-		return promise
-	}
-
-	/**
-	 * Clears the schema cache.
-	 */
-	clearCache(): void {
-		this.cache.clear()
-	}
-
-	/**
-	 * Clears cache for a specific API URL.
-	 */
-	clearCacheFor(apiUrl: string): void {
-		this.cache.delete(apiUrl)
-	}
-}
+export { SchemaLoader, type SchemaLoaderClient } from '@contember/bindx-client'

package/src/schema/SchemaRegistry.ts

@@ -1,286 +1 @@
-import type { ContemberSchema } from './ContemberSchema.js'
-import type {
-	EntitySchemaDef,
-	FieldDef,
-	HasManyRelationDef,
-	HasOneRelationDef,
-	RelationType,
-	SchemaDefinition,
-} from './types.js'
-
-/**
- * Runtime registry for entity schemas.
- * Provides lookups for entity definitions, relation targets, and field types.
- */
-export class SchemaRegistry<TModels extends Record<string, object> = Record<string, object>> {
-	private readonly entityDefs: Map<string, EntitySchemaDef>
-
-	constructor(definition: SchemaDefinition<TModels>) {
-		this.entityDefs = new Map()
-
-		for (const [entityName, entityDef] of Object.entries(definition.entities)) {
-			this.entityDefs.set(entityName, normalizeEntityDef(entityDef as EntitySchemaDef))
-		}
-	}
-
-	/**
-	 * Creates a SchemaRegistry from a ContemberSchema (loaded from API or injected).
-	 * This is the preferred way to create a SchemaRegistry at runtime.
-	 */
-	static fromContemberSchema(schema: ContemberSchema): SchemaRegistry {
-		const entities: Record<string, EntitySchemaDef> = {}
-
-		for (const entityName of schema.getEntityNames()) {
-			const entity = schema.getEntity(entityName)
-			if (!entity) continue
-
-			const fields: Record<string, FieldDef> = {}
-
-			for (const [fieldName, field] of entity.fields) {
-				if (field.__typename === '_Column') {
-					fields[fieldName] = { type: 'scalar' }
-				} else if (field.__typename === '_Relation') {
-					const isMany = field.type === 'OneHasMany' || field.type === 'ManyHasMany'
-					if (isMany) {
-						fields[fieldName] = {
-							type: 'hasMany',
-							target: field.targetEntity,
-							inverse: field.side === 'owning' ? field.inversedBy ?? undefined : field.ownedBy,
-						}
-					} else {
-						fields[fieldName] = {
-							type: 'hasOne',
-							target: field.targetEntity,
-							inverse: field.side === 'owning' ? field.inversedBy ?? undefined : field.ownedBy,
-						}
-					}
-				}
-			}
-
-			entities[entityName] = { fields }
-		}
-
-		return new SchemaRegistry({ entities } as SchemaDefinition<Record<string, object>>)
-	}
-
-	/**
-	 * Gets the entity names defined in the schema
-	 */
-	getEntityNames(): string[] {
-		return Array.from(this.entityDefs.keys())
-	}
-
-	/**
-	 * Checks if an entity type exists in the schema
-	 */
-	hasEntity(entityType: string): boolean {
-		return this.entityDefs.has(entityType)
-	}
-
-	/**
-	 * Gets the schema definition for an entity type
-	 */
-	getEntityDef(entityType: string): EntitySchemaDef | undefined {
-		return this.entityDefs.get(entityType)
-	}
-
-	/**
-	 * Gets the field definition for a specific field on an entity
-	 */
-	getFieldDef(entityType: string, fieldName: string): FieldDef | undefined {
-		const entityDef = this.entityDefs.get(entityType)
-		if (!entityDef) return undefined
-		return entityDef.fields[fieldName]
-	}
-
-	/**
-	 * Gets the enum values for an enum field.
-	 * Returns undefined if the field is not an enum or doesn't exist.
-	 */
-	getEnumValues(entityType: string, fieldName: string): readonly string[] | undefined {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		if (!fieldDef || fieldDef.type !== 'enum') return undefined
-		return fieldDef.values
-	}
-
-	/**
-	 * Gets the enum name for an enum field.
-	 * Returns undefined if the field is not an enum or doesn't exist.
-	 */
-	getEnumName(entityType: string, fieldName: string): string | undefined {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		if (!fieldDef || fieldDef.type !== 'enum') return undefined
-		return fieldDef.enumName
-	}
-
-	/**
-	 * Gets the column type for a scalar field (e.g. 'String', 'Integer', 'Date').
-	 * Returns undefined if the field is not a scalar or doesn't exist.
-	 */
-	getColumnType(entityType: string, fieldName: string): string | undefined {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		if (!fieldDef || fieldDef.type !== 'scalar') return undefined
-		return fieldDef.columnType
-	}
-
-	/**
-	 * Gets the target entity type for a relation field.
-	 * Returns undefined if the field is not a relation or doesn't exist.
-	 */
-	getRelationTarget(entityType: string, fieldName: string): string | undefined {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		if (!fieldDef) return undefined
-
-		if (fieldDef.type === 'hasOne' || fieldDef.type === 'hasMany') {
-			return fieldDef.target
-		}
-
-		return undefined
-	}
-
-	/**
-	 * Gets the relation type for a field (hasOne or hasMany).
-	 * Returns undefined if the field is not a relation.
-	 */
-	getRelationType(entityType: string, fieldName: string): RelationType | undefined {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		if (!fieldDef) return undefined
-
-		if (fieldDef.type === 'hasOne' || fieldDef.type === 'hasMany') {
-			return fieldDef.type
-		}
-
-		return undefined
-	}
-
-	/**
-	 * Checks if a field is a relation (hasOne or hasMany)
-	 */
-	isRelation(entityType: string, fieldName: string): boolean {
-		return this.getRelationType(entityType, fieldName) !== undefined
-	}
-
-	/**
-	 * Checks if a field is a has-one relation
-	 */
-	isHasOne(entityType: string, fieldName: string): boolean {
-		return this.getRelationType(entityType, fieldName) === 'hasOne'
-	}
-
-	/**
-	 * Checks if a field is a has-many relation
-	 */
-	isHasMany(entityType: string, fieldName: string): boolean {
-		return this.getRelationType(entityType, fieldName) === 'hasMany'
-	}
-
-	/**
-	 * Checks if a field is a scalar (non-relation) field
-	 */
-	isScalar(entityType: string, fieldName: string): boolean {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		return fieldDef?.type === 'scalar'
-	}
-
-	/**
-	 * Gets the inverse field name for a relation.
-	 * Returns undefined if no inverse is defined.
-	 */
-	getInverseField(entityType: string, fieldName: string): string | undefined {
-		const fieldDef = this.getFieldDef(entityType, fieldName)
-		if (!fieldDef) return undefined
-		if (fieldDef.type === 'scalar') return undefined
-
-		return (fieldDef as HasOneRelationDef | HasManyRelationDef).inverse
-	}
-
-	/**
-	 * Gets all scalar field names for an entity
-	 */
-	getScalarFields(entityType: string): string[] {
-		const entityDef = this.entityDefs.get(entityType)
-		if (!entityDef) return []
-
-		return Object.entries(entityDef.fields)
-			.filter(([_, def]) => def.type === 'scalar')
-			.map(([name]) => name)
-	}
-
-	/**
-	 * Gets all relation field names for an entity
-	 */
-	getRelationFields(entityType: string): string[] {
-		const entityDef = this.entityDefs.get(entityType)
-		if (!entityDef) return []
-
-		return Object.entries(entityDef.fields)
-			.filter(([_, def]) => def.type === 'hasOne' || def.type === 'hasMany')
-			.map(([name]) => name)
-	}
-
-	/**
-	 * Gets all field names for an entity
-	 */
-	getAllFields(entityType: string): string[] {
-		const entityDef = this.entityDefs.get(entityType)
-		if (!entityDef) return []
-
-		return Object.keys(entityDef.fields)
-	}
-
-	/**
-	 * Validates that all relation targets exist in the schema.
-	 * Throws an error if any target is missing.
-	 */
-	validate(): void {
-		for (const [entityName, entityDef] of this.entityDefs) {
-			for (const [fieldName, fieldDef] of Object.entries(entityDef.fields)) {
-				if (fieldDef.type === 'hasOne' || fieldDef.type === 'hasMany') {
-					if (!this.entityDefs.has(fieldDef.target)) {
-						throw new Error(
-							`Invalid schema: Entity "${entityName}" field "${fieldName}" references ` +
-								`unknown entity "${fieldDef.target}"`,
-						)
-					}
-				}
-			}
-		}
-	}
-}
-
-/**
- * Normalizes field definitions from Contember SchemaNames format
- * (column/one/many with entity) to bindx FieldDef format (scalar/hasOne/hasMany with target).
- */
-function normalizeEntityDef(entityDef: EntitySchemaDef): EntitySchemaDef {
-	const fields: Record<string, FieldDef> = {}
-	let needsNormalization = false
-
-	for (const [fieldName, fieldDef] of Object.entries(entityDef.fields)) {
-		const raw = fieldDef as unknown as Record<string, unknown>
-		const type = raw['type'] as string
-
-		if (type === 'column') {
-			fields[fieldName] = { type: 'scalar' }
-			needsNormalization = true
-		} else if (type === 'one') {
-			fields[fieldName] = {
-				type: 'hasOne',
-				target: (raw['entity'] as string) ?? (raw['target'] as string),
-				inverse: raw['inverse'] as string | undefined,
-			}
-			needsNormalization = true
-		} else if (type === 'many') {
-			fields[fieldName] = {
-				type: 'hasMany',
-				target: (raw['entity'] as string) ?? (raw['target'] as string),
-				inverse: raw['inverse'] as string | undefined,
-			}
-			needsNormalization = true
-		} else {
-			fields[fieldName] = fieldDef
-		}
-	}
-
-	return needsNormalization ? { fields } : entityDef
-}
+export { SchemaRegistry } from '@contember/bindx-client'

package/src/schema/roles.ts

@@ -1,83 +1,10 @@
-/**
- * Role-aware type utilities for bindx.
- *
- * The role system allows per-role field access control at the type level.
- * Default (no role) = narrowest scope (fields ALL roles can access).
- * Specifying roles = expanding scope (union of capabilities for those roles).
- */
-
-// ============================================================================
-// Core Utility Types
-// ============================================================================
-
-/**
- * Converts a union type to an intersection type.
- * Used to merge field sets from multiple roles.
- *
- * @example
- * UnionToIntersection<{ a: 1 } | { b: 2 }> = { a: 1 } & { b: 2 }
- */
-export type UnionToIntersection<U> =
-	(U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never
-
-// ============================================================================
-// Role Map Types
-// ============================================================================
-
-/**
- * Extracts all role names from a role map.
- */
-export type RoleNames<TRoleMap extends Record<string, object>> = keyof TRoleMap & string
-
-/**
- * Default entity type — the narrowest scope.
- * Returns a union of all role entity types, so only common fields are accessible via keyof.
- *
- * @example
- * CommonEntity<{ admin: { id: string; secret: string }; public: { id: string } }>
- * // = { id: string; secret: string } | { id: string }
- * // Only `id` is accessible (common to all roles)
- */
-export type CommonEntity<TRoleMap extends Record<string, object>> = TRoleMap[keyof TRoleMap]
-
-/**
- * Entity type for specific roles — expanded scope.
- * Returns an intersection of the specified roles' entity types,
- * giving access to all fields from any of those roles.
- *
- * @example
- * EntityForRoles<{ admin: { id: string; secret: string }; editor: { id: string; notes: string } }, 'admin'>
- * // = { id: string; secret: string }
- *
- * EntityForRoles<{ admin: { id: string; secret: string }; editor: { id: string; notes: string } }, 'admin' | 'editor'>
- * // = { id: string; secret: string } & { id: string; notes: string }
- * // = { id: string; secret: string; notes: string }
- */
-export type EntityForRoles<
-	TRoleMap extends Record<string, object>,
-	TRoles extends keyof TRoleMap,
-> = UnionToIntersection<TRoleMap[TRoles]> & object
-
-/**
- * Resolves the entity type based on whether roles are specified.
- * - No roles (TRoles = never): returns CommonEntity (narrowest)
- * - With roles: returns EntityForRoles (expanded)
- */
-export type ResolveEntity<
-	TRoleMap extends Record<string, object>,
-	TRoles extends string,
-> = [TRoles] extends [never]
-	? CommonEntity<TRoleMap>
-	: EntityForRoles<TRoleMap, TRoles & keyof TRoleMap>
-
-/**
- * Sentinel role name used when no ACL roles are defined.
- * entityDef<Article>('Article') wraps as { _default: Article }.
- */
-export const DEFAULT_ROLE = '_default' as const
-export type DefaultRole = typeof DEFAULT_ROLE
-
-/**
- * Wraps a single entity type as a single-role map with the _default role.
- */
-export type SingleRoleMap<TEntity extends object> = { readonly [K in DefaultRole]: TEntity }
+export {
+	type UnionToIntersection,
+	type RoleNames,
+	type CommonEntity,
+	type EntityForRoles,
+	type ResolveEntity,
+	type SingleRoleMap,
+	type DefaultRole,
+	DEFAULT_ROLE,
+} from '@contember/bindx-client'