@nuasite/cms-core 0.43.0-beta.1

package/src/content-config-ast.ts

@@ -0,0 +1,536 @@
+import { parse as parseBabel } from '@babel/parser'
+import type * as t from '@babel/types'
+import { type FieldHints, type FieldType, isFieldType } from '@nuasite/cms-types'
+import type { CmsFileSystem } from './fs/types'
+
+export interface ParsedReference {
+	target: string
+	isArray: boolean
+}
+
+export interface ParsedField {
+	name: string
+	type?: FieldType
+	options?: string[]
+	hints?: FieldHints
+	required: boolean
+	orderBy?: { direction: 'asc' | 'desc' }
+	reference?: ParsedReference
+	/** True when the field is `image()` from an Astro callback schema, which routes through `astro:assets`. */
+	astroImage?: boolean
+	/** Element type for `array` fields */
+	itemType?: FieldType
+	/** Nested fields for `object` fields, or per-item fields for `array` of objects */
+	fields?: ParsedField[]
+}
+
+export interface ParsedCollection {
+	name: string
+	fields: ParsedField[]
+	loaderPattern?: string
+	loaderBase?: string
+}
+
+export type ParsedConfig = Map<string, ParsedCollection>
+
+/** Cached parse result keyed by config path; invalidated by mtime. */
+export type ParseCache = Map<string, { mtimeMs: number; parsed: ParsedConfig }>
+
+const FIELD_HELPER_TYPES = new Set([
+	'text',
+	'number',
+	'image',
+	'file',
+	'url',
+	'email',
+	'tel',
+	'color',
+	'date',
+	'datetime',
+	'time',
+	'year',
+	'month',
+	'textarea',
+])
+
+const VALID_HINT_KEYS = new Set([
+	'min',
+	'max',
+	'step',
+	'placeholder',
+	'maxLength',
+	'minLength',
+	'rows',
+	'accept',
+])
+
+const WRAPPER_METHODS = new Set(['optional', 'nullable', 'nullish', 'default'])
+
+/** Map of top-level `const <name> = <expr>` bindings within a single config file. */
+type Bindings = Map<string, t.Node>
+
+/**
+ * Follow `Identifier` references through same-file `const` bindings until reaching
+ * a non-Identifier node. Cycle-safe via the visited set. Returns the original node
+ * unchanged when the identifier is unbound or already visited.
+ */
+function resolveExpression(node: t.Node, bindings: Bindings, visited: Set<string> = new Set()): t.Node {
+	let current: t.Node = node
+	while (current.type === 'Identifier') {
+		if (visited.has(current.name)) return current
+		visited.add(current.name)
+		const next = bindings.get(current.name)
+		if (!next) return current
+		current = next
+	}
+	return current
+}
+
+/**
+ * Parse a TypeScript/JS source string into a Babel `File`. Babel-only — no Astro
+ * coupling. Returns null when parsing throws fatally.
+ */
+function parseSource(source: string): t.File | null {
+	try {
+		return parseBabel(source, {
+			sourceType: 'module',
+			plugins: ['typescript'],
+			errorRecovery: true,
+		})
+	} catch {
+		return null
+	}
+}
+
+/**
+ * Parse the project's Astro content config file (TypeScript) into a structured
+ * representation of each collection's schema. Returns an empty map if no config
+ * file exists or parsing fails. The mtime-keyed cache (via `fs.stat()`) skips
+ * re-reading and re-parsing an unchanged config file.
+ */
+export async function parseContentConfig(fs: CmsFileSystem, cache: ParseCache): Promise<ParsedConfig> {
+	for (const configPath of ['src/content/config.ts', 'src/content.config.ts']) {
+		let stat: Awaited<ReturnType<CmsFileSystem['stat']>>
+		try {
+			stat = await fs.stat(configPath)
+		} catch {
+			continue
+		}
+
+		const cached = cache.get(configPath)
+		if (cached && cached.mtimeMs === stat.mtimeMs) {
+			if (cached.parsed.size > 0) return cached.parsed
+			continue
+		}
+
+		const content = await fs.readFile(configPath)
+		const parsed = parseConfigSource(content, configPath)
+		cache.set(configPath, { mtimeMs: stat.mtimeMs, parsed })
+		if (parsed.size > 0) return parsed
+	}
+	return new Map()
+}
+
+/** Exported for unit testing — operates on a source string directly. */
+export function parseConfigSource(source: string, _sourcePath?: string): ParsedConfig {
+	const result: ParsedConfig = new Map()
+	const ast = parseSource(source)
+	if (!ast) return result
+
+	// Single pass: collect every top-level `const X = <expr>` binding (so we can
+	// later resolve Identifier references like `cs: TestimonialTranslation`),
+	// while also picking out `defineCollection({...})` calls and the
+	// `export const collections = { name: X, ... }` mapping.
+	const bindings: Bindings = new Map()
+	const collectionDecls = new Map<string, t.ObjectExpression>()
+	const exportMap = new Map<string, string>() // varName → collectionName
+	const inlineCollections = new Map<string, t.ObjectExpression>() // collectionName → defineCollection arg (inline form)
+
+	for (const stmt of ast.program.body) {
+		const varDecl = stmt.type === 'ExportNamedDeclaration' && stmt.declaration?.type === 'VariableDeclaration'
+			? stmt.declaration
+			: stmt.type === 'VariableDeclaration'
+			? stmt
+			: null
+		if (!varDecl) continue
+
+		for (const decl of varDecl.declarations) {
+			if (decl.id.type !== 'Identifier') continue
+			if (!decl.init) continue
+
+			bindings.set(decl.id.name, decl.init)
+
+			if (decl.id.name === 'collections' && decl.init.type === 'ObjectExpression') {
+				for (const prop of decl.init.properties) {
+					if (prop.type !== 'ObjectProperty') continue
+					const key = propertyKeyName(prop.key)
+					if (!key) continue
+					if (prop.value.type === 'Identifier') {
+						exportMap.set(prop.value.name, key)
+					} else if (prop.value.type === 'CallExpression' && isDefineCollectionCallee(prop.value.callee)) {
+						// Inline form: `collections = { name: defineCollection({...}) }`
+						const inlineArg = prop.value.arguments[0]
+						if (inlineArg?.type === 'ObjectExpression') {
+							inlineCollections.set(key, inlineArg)
+						}
+					}
+				}
+				continue
+			}
+
+			if (decl.init.type === 'CallExpression' && isDefineCollectionCallee(decl.init.callee)) {
+				const arg = decl.init.arguments[0]
+				if (arg?.type === 'ObjectExpression') {
+					collectionDecls.set(decl.id.name, arg)
+				}
+			}
+		}
+	}
+
+	// Unify both styles: inline `name: defineCollection({...})` and the
+	// `const x = defineCollection({...}); collections = { name: x }` reference form.
+	const collectionObjects = new Map<string, t.ObjectExpression>(inlineCollections)
+	for (const [varName, collectionName] of exportMap) {
+		const decl = collectionDecls.get(varName)
+		if (decl) collectionObjects.set(collectionName, decl)
+	}
+
+	for (const [collectionName, decl] of collectionObjects) {
+		const loaderProperty = decl.properties.find(
+			p =>
+				p.type === 'ObjectProperty'
+				&& propertyKeyName(p.key) === 'loader',
+		)
+		const loaderOptions = loaderProperty?.type === 'ObjectProperty' ? extractGlobLoaderOptions(loaderProperty.value, bindings) : {}
+		const loaderPattern = loaderOptions.pattern
+		const loaderBase = loaderOptions.base
+
+		const schemaProperty = decl.properties.find(
+			p =>
+				p.type === 'ObjectProperty'
+				&& propertyKeyName(p.key) === 'schema',
+		)
+		if (!schemaProperty || schemaProperty.type !== 'ObjectProperty') {
+			if (!loaderPattern) continue
+			result.set(collectionName, {
+				name: collectionName,
+				fields: [],
+				loaderPattern,
+				loaderBase,
+			})
+			continue
+		}
+
+		const schemaObject = unwrapSchemaToObject(schemaProperty.value, bindings)
+		if (!schemaObject) {
+			if (!loaderPattern) continue
+			result.set(collectionName, {
+				name: collectionName,
+				fields: [],
+				loaderPattern,
+				loaderBase,
+			})
+			continue
+		}
+
+		result.set(collectionName, {
+			name: collectionName,
+			fields: parseSchemaFields(schemaObject, bindings),
+			loaderPattern,
+			loaderBase,
+		})
+	}
+
+	return result
+}
+
+function isDefineCollectionCallee(callee: t.Node): boolean {
+	return callee.type === 'Identifier' && callee.name === 'defineCollection'
+}
+
+function propertyKeyName(key: t.Node): string | null {
+	if (key.type === 'Identifier') return key.name
+	if (key.type === 'StringLiteral') return key.value
+	return null
+}
+
+function extractGlobLoaderOptions(node: t.Node, bindings: Bindings): { pattern?: string; base?: string } {
+	const resolved = resolveExpression(node, bindings)
+	if (resolved.type !== 'CallExpression') return {}
+	if (!isGlobCallee(resolved.callee)) return {}
+
+	const arg = resolved.arguments[0]
+	if (!arg) return {}
+	const options = resolveExpression(arg, bindings)
+	if (options.type !== 'ObjectExpression') return {}
+
+	const result: { pattern?: string; base?: string } = {}
+	for (const prop of options.properties) {
+		if (prop.type !== 'ObjectProperty') continue
+		const key = propertyKeyName(prop.key)
+		if (key !== 'pattern' && key !== 'base') continue
+		const value = extractStaticString(prop.value, bindings)
+		if (value !== undefined) result[key] = value
+	}
+
+	return result
+}
+
+function extractStaticString(node: t.Node, bindings: Bindings): string | undefined {
+	const resolved = resolveExpression(node, bindings)
+	if (resolved.type === 'StringLiteral') return resolved.value
+	if (resolved.type === 'TemplateLiteral' && resolved.expressions.length === 0) {
+		return resolved.quasis[0]?.value.cooked ?? resolved.quasis[0]?.value.raw
+	}
+	return undefined
+}
+
+function isGlobCallee(callee: t.Node): boolean {
+	return callee.type === 'Identifier' && callee.name === 'glob'
+}
+
+/**
+ * Unwrap a `schema:` value down to the top-level (z|n).object({ ... }) ObjectExpression.
+ * Handles direct calls, the Astro callback form `({ image }) => z.object({...})`,
+ * and same-file variable references like `schema: BlogSchema`.
+ */
+function unwrapSchemaToObject(node: t.Node, bindings: Bindings): t.ObjectExpression | null {
+	const resolved = resolveExpression(node, bindings)
+
+	if (resolved.type === 'ArrowFunctionExpression' || resolved.type === 'FunctionExpression') {
+		const body = resolved.body
+		if (body.type === 'BlockStatement') {
+			for (const stmt of body.body) {
+				if (stmt.type === 'ReturnStatement' && stmt.argument) {
+					return unwrapSchemaToObject(stmt.argument, bindings)
+				}
+			}
+			return null
+		}
+		return unwrapSchemaToObject(body, bindings)
+	}
+
+	if (resolved.type === 'CallExpression') {
+		const callee = resolved.callee
+		if (
+			callee.type === 'MemberExpression'
+			&& callee.object.type === 'Identifier'
+			&& (callee.object.name === 'z' || callee.object.name === 'n')
+			&& callee.property.type === 'Identifier'
+			&& callee.property.name === 'object'
+		) {
+			const arg = resolved.arguments[0]
+			if (!arg) return null
+			const resolvedArg = resolveExpression(arg, bindings)
+			if (resolvedArg.type === 'ObjectExpression') return resolvedArg
+		}
+	}
+
+	return null
+}
+
+function parseSchemaFields(schemaObject: t.ObjectExpression, bindings: Bindings): ParsedField[] {
+	const fields: ParsedField[] = []
+	for (const prop of schemaObject.properties) {
+		if (prop.type !== 'ObjectProperty') continue
+		const name = propertyKeyName(prop.key)
+		if (!name) continue
+
+		const field: ParsedField = { name, required: true }
+		analyzeFieldExpression(prop.value, field, bindings)
+		fields.push(field)
+	}
+	return fields
+}
+
+/**
+ * Walk a field's value expression. Each layer is either a wrapper method call
+ * (`.optional()`, `.default()`, `.nullable()`, `.nullish()`, `.orderBy(...)`)
+ * or the base call (`n.image()`, `image()`, `z.enum([...])`, `n.array(reference(...))`).
+ *
+ * Resolves same-file `Identifier` references against `bindings` at each layer so
+ * patterns like `cs: TestimonialTranslation` and `en: TestimonialTranslation.optional()`
+ * are followed back to their defining call.
+ */
+function analyzeFieldExpression(node: t.Node, field: ParsedField, bindings: Bindings): void {
+	let current: t.Node | null = resolveExpression(node, bindings)
+	while (current) {
+		if (current.type !== 'CallExpression') return
+
+		if (isBaseCall(current)) {
+			analyzeBaseCall(current, field, bindings)
+			return
+		}
+
+		if (current.callee.type !== 'MemberExpression') return
+		const property = current.callee.property
+		const methodName = property.type === 'Identifier' ? property.name : ''
+
+		if (WRAPPER_METHODS.has(methodName)) {
+			field.required = false
+		} else if (methodName === 'orderBy') {
+			const arg = current.arguments[0]
+			const direction = arg?.type === 'StringLiteral' && arg.value === 'desc' ? 'desc' : 'asc'
+			field.orderBy = { direction }
+		}
+
+		current = resolveExpression(current.callee.object, bindings)
+	}
+}
+
+/**
+ * A "base call" is the innermost call that defines the field's type: a Zod/n
+ * helper invocation or a bare `image()` / `reference()` from a callback param.
+ */
+function isBaseCall(node: t.CallExpression): boolean {
+	const callee = node.callee
+	if (callee.type === 'Identifier') {
+		return callee.name === 'image' || callee.name === 'reference'
+	}
+	if (callee.type === 'MemberExpression') {
+		return callee.object.type === 'Identifier'
+			&& (callee.object.name === 'n' || callee.object.name === 'z')
+	}
+	return false
+}
+
+function analyzeBaseCall(node: t.CallExpression, field: ParsedField, bindings: Bindings): void {
+	const callee = node.callee
+
+	// Bare image() / reference() from the schema callback form
+	if (callee.type === 'Identifier') {
+		if (callee.name === 'image') {
+			field.type = 'image'
+			field.astroImage = true
+			return
+		}
+		if (callee.name === 'reference') {
+			const arg = node.arguments[0]
+			if (arg?.type === 'StringLiteral') {
+				field.reference = { target: arg.value, isArray: false }
+			}
+			return
+		}
+		return
+	}
+
+	if (callee.type !== 'MemberExpression') return
+	if (callee.object.type !== 'Identifier' || callee.property.type !== 'Identifier') return
+	const ns = callee.object.name
+	const fn = callee.property.name
+
+	// n.image(), n.url(), n.text(...), etc. — semantic field types from @nuasite/cms.
+	// FIELD_HELPER_TYPES gates to the helper subset (excludes boolean/select/array/object/
+	// reference, which are inferred elsewhere); isFieldType narrows `fn` to FieldType.
+	if (ns === 'n' && FIELD_HELPER_TYPES.has(fn) && isFieldType(fn)) {
+		field.type = fn
+		const firstArg = node.arguments[0]
+		if (firstArg?.type === 'ObjectExpression') {
+			const hints = parseHintsFromObject(firstArg)
+			if (hints) field.hints = hints
+		}
+		return
+	}
+
+	// (z|n).enum([...])  →  select with options
+	if ((ns === 'z' || ns === 'n') && fn === 'enum') {
+		const arg = node.arguments[0]
+		if (arg?.type === 'ArrayExpression') {
+			const options: string[] = []
+			for (const el of arg.elements) {
+				if (el?.type === 'StringLiteral') options.push(el.value)
+			}
+			if (options.length > 0) {
+				field.type = 'select'
+				field.options = options
+			}
+		}
+		return
+	}
+
+	// (z|n).object({...})  →  nested object field
+	if ((ns === 'z' || ns === 'n') && fn === 'object') {
+		const arg = node.arguments[0]
+		if (!arg) return
+		const resolved = resolveExpression(arg, bindings)
+		if (resolved.type === 'ObjectExpression') {
+			field.type = 'object'
+			field.fields = parseSchemaFields(resolved, bindings)
+		}
+		return
+	}
+
+	// (z|n).array(<inner>)  →  array; inspect the element type
+	if ((ns === 'z' || ns === 'n') && fn === 'array') {
+		const innerRaw = node.arguments[0]
+		if (!innerRaw) return
+		const inner = resolveExpression(innerRaw, bindings)
+		// Array of references: keep the existing flat shape so detectReferenceFields can wire it up.
+		if (
+			inner.type === 'CallExpression'
+			&& inner.callee.type === 'Identifier'
+			&& inner.callee.name === 'reference'
+		) {
+			const target = inner.arguments[0]
+			if (target?.type === 'StringLiteral') {
+				field.reference = { target: target.value, isArray: true }
+			}
+			return
+		}
+		// Array of anything else: analyze the inner expression and lift its type/fields.
+		// Note: nested arrays (`n.array(n.array(...))`) collapse here — `itemType` records
+		// only the outer element type, the inner element shape is lost. No editor flow
+		// currently renders nested arrays, so we don't carry a recursive `itemDefinition`
+		// yet; add one when editor support arrives.
+		const innerField: ParsedField = { name: '__item__', required: true }
+		analyzeFieldExpression(inner, innerField, bindings)
+		field.type = 'array'
+		if (innerField.type) field.itemType = innerField.type
+		if (innerField.fields) field.fields = innerField.fields
+		return
+	}
+}
+
+function parseHintsFromObject(obj: t.ObjectExpression): FieldHints | undefined {
+	const raw: { [K in keyof FieldHints]: FieldHints[K] } = {}
+	for (const prop of obj.properties) {
+		if (prop.type !== 'ObjectProperty') continue
+		const key = propertyKeyName(prop.key)
+		if (!key || !VALID_HINT_KEYS.has(key)) continue
+
+		const value = prop.value
+		if (value.type === 'NumericLiteral') {
+			assignHint(raw, key, value.value)
+		} else if (
+			value.type === 'UnaryExpression'
+			&& value.operator === '-'
+			&& value.argument.type === 'NumericLiteral'
+		) {
+			assignHint(raw, key, -value.argument.value)
+		} else if (value.type === 'StringLiteral') {
+			assignHint(raw, key, value.value)
+		}
+	}
+	if (Object.keys(raw).length === 0) return undefined
+	return raw
+}
+
+/** Assign a parsed hint value onto the hints object, narrowing per the FieldHints shape. */
+function assignHint(hints: FieldHints, key: string, value: string | number): void {
+	switch (key) {
+		case 'min':
+		case 'max':
+			hints[key] = value
+			return
+		case 'step':
+		case 'maxLength':
+		case 'minLength':
+		case 'rows':
+			if (typeof value === 'number') hints[key] = value
+			return
+		case 'placeholder':
+		case 'accept':
+			if (typeof value === 'string') hints[key] = value
+			return
+	}
+}

package/src/core.ts

@@ -0,0 +1,167 @@
+import type {
+	AddRedirectRequest,
+	CollectionDefinition,
+	ComponentDefinition,
+	CreatePageRequest,
+	DeletePageRequest,
+	DeleteRedirectRequest,
+	DuplicatePageRequest,
+	GetRedirectsResponse,
+	LayoutInfo,
+	MediaStorageAdapter,
+	MutationResult,
+	PageOperationResponse,
+	RedirectOperationResponse,
+	UpdateRedirectRequest,
+} from '@nuasite/cms-types'
+import { scanCollections } from './collection-scanner'
+import { scanComponentDefinitions } from './component-registry'
+import { type ParseCache } from './content-config-ast'
+import type { CmsFileSystem } from './fs/types'
+import {
+	addArrayItem as addArrayItemOp,
+	type AddArrayItemInput,
+	createEntry as createEntryOp,
+	type CreateEntryInput,
+	deleteEntry as deleteEntryOp,
+	type EntryOpsDeps,
+	getEntry as getEntryOp,
+	type GetEntryResult,
+	removeArrayItem as removeArrayItemOp,
+	type RemoveArrayItemInput,
+	renameEntry as renameEntryOp,
+	updateEntry as updateEntryOp,
+	type UpdateEntryInput,
+} from './handlers/entry-ops'
+import {
+	createPage as createPageOp,
+	deletePage as deletePageOp,
+	duplicatePage as duplicatePageOp,
+	getLayouts as getLayoutsOp,
+} from './handlers/page-ops'
+import {
+	addRedirect as addRedirectOp,
+	deleteRedirect as deleteRedirectOp,
+	listRedirects as listRedirectsOp,
+	updateRedirect as updateRedirectOp,
+} from './handlers/redirect-ops'
+
+export interface CmsCoreOptions {
+	/** Content collections directory, relative to the filesystem root. Defaults to `src/content`. */
+	contentDir?: string
+	/** Pluggable media storage adapter (local / s3 / contember). */
+	media?: MediaStorageAdapter
+	/** Directories to scan for Astro components (used for MDX import resolution). Defaults to `['src/components']`. */
+	componentDirs?: string[]
+}
+
+/**
+ * The framework-agnostic CMS brain over a `CmsFileSystem` port.
+ *
+ * Exposes the read/scan surface plus the structural mutations (entry / array /
+ * page / redirect CRUD) and a pluggable media adapter. All I/O flows through the
+ * injected `CmsFileSystem`; nothing here knows about Astro, Vite, HTTP or the
+ * render-time page manifest.
+ */
+export interface CmsCore {
+	// READ / SCAN
+	/** Scan all content collections, returning their inferred definitions keyed by name. */
+	scanCollections(): Promise<Record<string, CollectionDefinition>>
+	/** Resolve the Astro component definitions used for MDX import injection. */
+	scanComponents(): Promise<Record<string, ComponentDefinition>>
+	/** Read a single entry's frontmatter + body, or `null` when it does not exist. */
+	getEntry(collection: string, slug: string): Promise<GetEntryResult | null>
+
+	// ENTRY MUTATIONS
+	createEntry(input: CreateEntryInput): Promise<MutationResult>
+	updateEntry(input: UpdateEntryInput): Promise<MutationResult>
+	deleteEntry(collection: string, slug: string): Promise<MutationResult>
+	renameEntry(collection: string, from: string, to: string): Promise<MutationResult>
+
+	// ENTRY-FRONTMATTER ARRAY FIELDS
+	addArrayItem(input: AddArrayItemInput): Promise<MutationResult>
+	removeArrayItem(input: RemoveArrayItemInput): Promise<MutationResult>
+
+	// PAGES / REDIRECTS
+	createPage(input: CreatePageRequest): Promise<PageOperationResponse>
+	duplicatePage(input: DuplicatePageRequest): Promise<PageOperationResponse>
+	deletePage(input: DeletePageRequest): Promise<PageOperationResponse>
+	getLayouts(): Promise<LayoutInfo[]>
+	listRedirects(): Promise<GetRedirectsResponse>
+	addRedirect(input: AddRedirectRequest): Promise<RedirectOperationResponse>
+	updateRedirect(input: UpdateRedirectRequest): Promise<RedirectOperationResponse>
+	deleteRedirect(input: DeleteRedirectRequest): Promise<RedirectOperationResponse>
+
+	// MEDIA (pluggable adapter; undefined when none is configured)
+	media?: MediaStorageAdapter
+}
+
+export function createCmsCore(fs: CmsFileSystem, opts: CmsCoreOptions = {}): CmsCore {
+	const contentDir = opts.contentDir ?? 'src/content'
+	const componentDirs = opts.componentDirs ?? ['src/components']
+	// One mtime-keyed content-config parse cache per core instance (per project root).
+	const parseCache: ParseCache = new Map()
+
+	const entryDeps: EntryOpsDeps = {
+		fs,
+		contentDir,
+		parseCache,
+		componentDirs,
+		resolveComponentDefinitions: () => scanComponentDefinitions(fs, componentDirs),
+	}
+
+	return {
+		scanCollections() {
+			return scanCollections(fs, contentDir, parseCache)
+		},
+		scanComponents() {
+			return scanComponentDefinitions(fs, componentDirs)
+		},
+		getEntry(collection, slug) {
+			return getEntryOp(entryDeps, collection, slug)
+		},
+		createEntry(input) {
+			return createEntryOp(entryDeps, input)
+		},
+		updateEntry(input) {
+			return updateEntryOp(entryDeps, input)
+		},
+		deleteEntry(collection, slug) {
+			return deleteEntryOp(entryDeps, collection, slug)
+		},
+		renameEntry(collection, from, to) {
+			return renameEntryOp(entryDeps, collection, from, to)
+		},
+		addArrayItem(input) {
+			return addArrayItemOp(entryDeps, input)
+		},
+		removeArrayItem(input) {
+			return removeArrayItemOp(entryDeps, input)
+		},
+		createPage(input) {
+			return createPageOp({ fs }, input)
+		},
+		duplicatePage(input) {
+			return duplicatePageOp({ fs }, input)
+		},
+		deletePage(input) {
+			return deletePageOp({ fs }, input)
+		},
+		getLayouts() {
+			return getLayoutsOp({ fs })
+		},
+		listRedirects() {
+			return listRedirectsOp({ fs })
+		},
+		addRedirect(input) {
+			return addRedirectOp({ fs }, input)
+		},
+		updateRedirect(input) {
+			return updateRedirectOp({ fs }, input)
+		},
+		deleteRedirect(input) {
+			return deleteRedirectOp({ fs }, input)
+		},
+		media: opts.media,
+	}
+}