@stonecrop/nuxt 0.13.9 → 0.13.11

package/templates/resolvers.ts

@@ -1,141 +1,173 @@
 /**
  * Stonecrop GraphQL Resolvers
  *
- * This file contains resolver implementations for the Stonecrop GraphQL schema.
- * Customize these resolvers to connect to your data sources.
+ * Uses Grafast plan resolvers — functions that return Steps (execution plans)
+ * rather than raw data. The key step functions used here:
  *
- * Grafast uses a planning-based execution model where resolvers return "steps"
- * (execution plans) rather than raw data. Common step functions:
- * - constant(value) - Returns a constant value
- * - context() - Accesses request context
- * - object({ ... }) - Creates an object with planned properties
- * - access($step, 'property') - Accesses a property from another step
- * - lambda($step, fn) - Transforms a step SYNCHRONOUSLY (no async/await!)
- * - loadOne($step, fn) - Batch loads data ASYNCHRONOUSLY (for DB queries)
- * - list([$a, $b]) - Combines multiple steps into a tuple
+ * - constant(value)           — return a static value
+ * - lambda($step, fn)         — transform a step SYNCHRONOUSLY (no async/await)
+ * - loadOne($step, fn)        — batch-load data ASYNCHRONOUSLY (for DB queries)
+ * - object({ ... })           — group multiple steps into a single step object
  *
- * CRITICAL RULES:
- * 1. lambda functions MUST be synchronous. For async operations, use loadOne/loadMany.
- * 2. Plan resolver args come pre-destructured with $ prefix: (_$parent, { $argName }) => ...
- * 3. Never call access() on args - they're already steps!
+ * Data reads go through loadOne; data writes happen in server/plugins/stonecrop.ts
+ * via registered action handlers (start_task, complete_task, archive_project).
+ *
+ * To connect a real database, replace the imports from ./data with your
+ * PostGraphile setup. See: https://stonecrop.io/docs/guides/postgraphile
  */
 
-// Import Grafast step functions
-// IMPORTANT: Must import from 'grafast' not 'postgraphile/grafast' for Nitro bundling
-import { constant, lambda, list } from 'grafast'
+import { constant, lambda, loadOne, object } from 'grafast'
+import { getMeta, getAllMeta, getHandler } from '@stonecrop/graphql-middleware'
+import type { ActionContext } from '@stonecrop/graphql-middleware'
+import type { DoctypeMeta } from '@stonecrop/schema'
+import { projects, tasks, type Project, type Task } from './data'
+
+// ============================================================
+// Formatting helpers (shape doctype metadata for the GraphQL
+// response type defined in server/schema.graphql)
+// ============================================================
+
+function formatFieldMeta(field: { kind?: string; fieldname: string; fieldtype?: string; [key: string]: unknown }) {
+	return {
+		fieldname: field.fieldname,
+		fieldtype: field.fieldtype ?? null,
+		label: field.label ?? null,
+		required: field.required ?? false,
+		readOnly: field.readOnly ?? false,
+		options: field.options ?? null,
+		default: field.default ?? null,
+		width: field.width ?? null,
+		validation: field.validation ?? null,
+		component: field.component ?? null,
+		align: field.align ?? null,
+		edit: field.edit ?? null,
+		hidden: field.hidden ?? null,
+		mask: field.mask ?? null,
+		precision: field.precision ?? null,
+		scale: field.scale ?? null,
+		mode: field.mode ?? null,
+	}
+}
+
+function formatDoctypeMeta(meta: DoctypeMeta) {
+	const actions = meta.workflow?.actions
+	const actionList = actions
+		? Object.entries(actions as Record<string, Record<string, unknown>>).map(([name, action]) => ({
+				name,
+				label: action.label ?? null,
+				handler: action.handler ?? null,
+				requiredFields: (action.requiredFields as string[]) ?? [],
+				allowedStates: (action.allowedStates as string[]) ?? [],
+				confirm: action.confirm ?? false,
+				args: action.args ?? null,
+			}))
+		: []
+	return {
+		name: meta.name,
+		slug: meta.slug ?? null,
+		fields: meta.fields.map(formatFieldMeta),
+		workflow: meta.workflow
+			? {
+					states: meta.workflow.states ?? null,
+					actions: actionList,
+				}
+			: null,
+		inherits: meta.inherits ?? null,
+	}
+}
+
+// ============================================================
+// Record helpers — read/write the in-memory Maps by doctype
+// ============================================================
+
+function getRecord(doctype: string, id: string): Project | Task | null {
+	const d = doctype.toLowerCase()
+	if (d === 'project') return projects.get(id) ?? null
+	if (d === 'task') return tasks.get(id) ?? null
+	return null
+}
+
+function getRecords(doctype: string, filters?: Record<string, unknown>): (Project | Task)[] {
+	const d = doctype.toLowerCase()
+	if (d === 'project') {
+		return Array.from(projects.values())
+	}
+	if (d === 'task') {
+		let all = Array.from(tasks.values())
+		if (filters?.projectId) {
+			all = all.filter(t => t.projectId === filters.projectId)
+		}
+		return all
+	}
+	return []
+}
+
+function nextId(doctype: string): string {
+	const d = doctype.toLowerCase()
+	const ids = d === 'project' ? projects.keys() : tasks.keys()
+	const max = Math.max(0, ...Array.from(ids, id => Number(id) || 0))
+	return String(max + 1)
+}
 
-// Import Stonecrop middleware for doctype metadata
-// import { getMeta, getAllMeta } from '@stonecrop/graphql-middleware'
+// ============================================================
+// Resolvers (Grafast plan format)
+// ============================================================
 
 export const resolvers = {
 	Query: {
 		plans: {
-			/**
-			 * Health check endpoint
-			 * Returns a constant object with health status
-			 */
 			healthCheck() {
-				return constant({
-					status: 'healthy',
-					timestamp: new Date().toISOString(),
-					version: '1.0.0',
-				})
+				return constant({ status: 'healthy', timestamp: new Date().toISOString(), version: '1.0.0' })
 			},
 
-			/**
-			 * Get metadata for a specific doctype
-			 * Connect this to your doctype registry or database
-			 */
-			getMeta(_$parent, { $doctype }) {
-				// $doctype is already a step from destructured args
-
-				// TODO: Implement doctype metadata lookup
-				// For synchronous lookups, use lambda:
-				// return lambda($doctype, doctype => {
-				// 	const meta = getMeta(doctype) // Must be synchronous!
-				// 	return meta ? formatDoctypeMeta(meta) : null
-				// })
-				//
-				// For async lookups, use loadOne:
-				// return loadOne($doctype, async doctypes => {
-				// 	return await Promise.all(
-				// 		doctypes.map(async dt => {
-				// 			const meta = await fetchMeta(dt)
-				// 			return meta ? formatDoctypeMeta(meta) : null
-				// 		})
-				// 	)
-				// })
+			getMeta(_: unknown, { $doctype }: any) {
+				return lambda($doctype, (doctype: unknown) => {
+					const meta = getMeta(doctype as string)
+					return meta ? formatDoctypeMeta(meta) : null
+				})
+			},
 
-				return lambda($doctype, doctype => {
-					console.log('getMeta called for:', doctype)
-					return null
+			stonecropMeta(_: unknown, { $doctype }: any) {
+				return lambda($doctype, (doctype: unknown) => {
+					const meta = getMeta(doctype as string)
+					return meta ? formatDoctypeMeta(meta) : null
 				})
 			},
 
-			/**
-			 * Get all registered doctype metadata
-			 * Returns an array of doctype metadata
-			 */
 			stonecropAllMeta() {
-				// TODO: Implement - return all doctype metadata
-				// Example with graphql-middleware:
-				// return constant(getAllMeta().map(formatDoctypeMeta))
-
-				return constant([])
+				return constant(getAllMeta().map(formatDoctypeMeta))
 			},
 
-			/**
-			 * Get a single record by doctype and ID
-			 */
-			stonecropRecord(_$parent, { $doctype, $id }) {
-				// Arguments come pre-destructured as steps with $ prefix
-
-				// TODO: Implement record fetching from your database
-				// Use loadOne for async database queries:
-				// return loadOne(list([$doctype, $id]), async pairs => {
-				// 	return await Promise.all(
-				// 		pairs.map(async ([doctype, id]) => {
-				// 			const record = await fetchRecordFromDB(doctype, id)
-				// 			return { data: record, doctype }
-				// 		})
-				// 	)
-				// })
-
-				return lambda(list([$doctype, $id]), ([doctype, id]) => {
-					console.log('stonecropRecord called:', { doctype, id })
-					return {
-						data: null,
-						doctype,
-					}
+			stonecropRecord(_: unknown, { $doctype, $id, $options }: any) {
+				return loadOne(object({ doctype: $doctype, id: $id, options: $options }), async (specs: readonly any[]) => {
+					return specs.map(spec => ({
+						data: getRecord(spec.doctype, spec.id),
+						doctype: spec.doctype,
+					}))
 				})
 			},
 
-			/**
-			 * Get multiple records with filtering
-			 */
-			stonecropRecords(_$parent, { $doctype, $filters, $orderBy, $limit, $offset, $options }) {
-				// Arguments come pre-destructured as steps with $ prefix
-
-				// TODO: Implement records fetching from your database
-				// Use loadOne for async database queries:
-				// return loadOne(list([$doctype, $filters, $orderBy, $limit, $offset]), async queryParams => {
-				// 	return await Promise.all(
-				// 		queryParams.map(async ([doctype, filters, orderBy, limit, offset]) => {
-				// 			const result = await queryRecordsFromDB(doctype, { filters, orderBy, limit, offset })
-				// 			return { data: result.records, doctype, count: result.totalCount }
-				// 		})
-				// 	)
-				// })
-
-				return lambda(
-					list([$doctype, $filters, $orderBy, $limit, $offset, $options]),
-					([doctype, filters, orderBy, limit, offset, options]) => {
-						console.log('stonecropRecords called:', { doctype, filters, orderBy, limit, offset, options })
-						return {
-							data: [],
-							doctype,
-							count: 0,
-						}
+			stonecropRecords(_: unknown, { $doctype, $filters, $orderBy, $limit, $offset, $options }: any) {
+				return loadOne(
+					object({
+						doctype: $doctype,
+						filters: $filters,
+						orderBy: $orderBy,
+						limit: $limit,
+						offset: $offset,
+						options: $options,
+					}),
+					async (specs: readonly any[]) => {
+						return specs.map(spec => {
+							const all = getRecords(spec.doctype, spec.filters ?? {})
+							const offset = spec.offset ?? 0
+							const limit = spec.limit ?? 100
+							return {
+								data: all.slice(offset, offset + limit),
+								doctype: spec.doctype,
+								count: all.length,
+							}
+						})
 					}
 				)
 			},
@@ -144,109 +176,94 @@ export const resolvers = {
 
 	Mutation: {
 		plans: {
-			/**
-			 * Execute a doctype action (workflow actions like activate, archive, etc.)
-			 */
-			stonecropAction(_$parent, { $doctype, $action, $args }) {
-				// Arguments come pre-destructured as steps with $ prefix
+			stonecropAction(_: unknown, { $doctype, $action, $args: $actionArgs }: any) {
+				return loadOne(
+					object({ doctype: $doctype, action: $action, actionArgs: $actionArgs }),
+					async (specs: readonly any[]) => {
+						return Promise.all(
+							specs.map(async spec => {
+								const meta = getMeta(spec.doctype)
+								if (!meta) return { success: false, data: null, error: `Unknown doctype: ${spec.doctype}` }
 
-				// TODO: Implement action execution
-				// Use loadOne for async operations:
-				// return loadOne(list([$doctype, $action, $args]), async actionParams => {
-				// 	return await Promise.all(
-				// 		actionParams.map(async ([doctype, action, actionArgs]) => {
-				// 			const result = await executeAction(doctype, action, actionArgs)
-				// 			return { success: result.success, data: result.data, error: result.error }
-				// 		})
-				// 	)
-				// })
+								const actionDef = meta.workflow?.actions?.[spec.action]
+								if (!actionDef) return { success: false, data: null, error: `Unknown action: ${spec.action}` }
 
-				return lambda(list([$doctype, $action, $args]), ([doctype, action, actionArgs]) => {
-					console.log('stonecropAction called:', { doctype, action, args: actionArgs })
-					return {
-						success: true,
-						data: null,
-						error: null,
-					}
-				})
-			},
+								const handler = getHandler(actionDef.handler)
+								if (!handler)
+									return { success: false, data: null, error: `Handler not registered: ${actionDef.handler}` }
 
-			/**
-			 * Create a new record
-			 */
-			stonecropCreate(_$parent, { $doctype, $input }) {
-				// Arguments come pre-destructured as steps with $ prefix
+								// Pass doctype metadata via ActionContext. The handler in server/plugins/stonecrop.ts
+								// imports and mutates the data Maps directly — it does not need additional context here.
+								// In a PostGraphile setup, context.pgClient would provide the database connection instead.
+								const actionContext: ActionContext = { doctype: meta }
 
-				// TODO: Implement record creation
-				// Use loadOne for async database operations:
-				// return loadOne(list([$doctype, $input]), async createParams => {
-				// 	return await Promise.all(
-				// 		createParams.map(async ([doctype, input]) => {
-				// 			const newRecord = await createRecordInDB(doctype, input)
-				// 			return { data: newRecord, doctype }
-				// 		})
-				// 	)
-				// })
-
-				return lambda(list([$doctype, $input]), ([doctype, input]) => {
-					console.log('stonecropCreate called:', { doctype, input })
-					return {
-						data: { id: 'new-id', ...input },
-						doctype,
+								try {
+									const result = await handler(spec.actionArgs ?? [], actionContext)
+									return { success: true, data: result, error: null }
+								} catch (err) {
+									return { success: false, data: null, error: err instanceof Error ? err.message : String(err) }
+								}
+							})
+						)
 					}
-				})
+				)
 			},
 
-			/**
-			 * Update an existing record
-			 */
-			stonecropUpdate(_$parent, { $doctype, $id, $patch }) {
-				// Arguments come pre-destructured as steps with $ prefix
-
-				// TODO: Implement record update
-				// Use loadOne for async database operations:
-				// return loadOne(list([$doctype, $id, $patch]), async updateParams => {
-				// 	return await Promise.all(
-				// 		updateParams.map(async ([doctype, id, patch]) => {
-				// 			const updatedRecord = await updateRecordInDB(doctype, id, patch)
-				// 			return { data: updatedRecord, doctype }
-				// 		})
-				// 	)
-				// })
-
-				return lambda(list([$doctype, $id, $patch]), ([doctype, id, patch]) => {
-					console.log('stonecropUpdate called:', { doctype, id, patch })
-					return {
-						data: { id, ...patch },
-						doctype,
-					}
+			stonecropCreate(_: unknown, { $doctype, $input }: any) {
+				return loadOne(object({ doctype: $doctype, input: $input }), async (specs: readonly any[]) => {
+					return specs.map(spec => {
+						const d = spec.doctype.toLowerCase()
+						const id = nextId(d)
+						const now = new Date().toISOString()
+						if (d === 'project') {
+							const record: Project = { id, createdAt: now, status: 'Active', description: '', ...spec.input }
+							projects.set(id, record)
+							return { data: record, doctype: spec.doctype }
+						}
+						if (d === 'task') {
+							const record: Task = { id, createdAt: now, status: 'Todo', description: '', dueDate: null, ...spec.input }
+							tasks.set(id, record)
+							return { data: record, doctype: spec.doctype }
+						}
+						return { data: null, doctype: spec.doctype }
+					})
 				})
 			},
 
-			/**
-			 * Delete a record
-			 */
-			stonecropDelete(_$parent, { $doctype, $id }) {
-				// Arguments come pre-destructured as steps with $ prefix
-
-				// TODO: Implement record deletion
-				// Use loadOne for async database operations:
-				// return loadOne(list([$doctype, $id]), async deleteParams => {
-				// 	return await Promise.all(
-				// 		deleteParams.map(async ([doctype, id]) => {
-				// 			await deleteRecordFromDB(doctype, id)
-				// 			return { success: true, data: { id }, error: null }
-				// 		})
-				// 	)
-				// })
+			stonecropUpdate(_: unknown, { $doctype, $id, $patch }: any) {
+				return loadOne(object({ doctype: $doctype, id: $id, patch: $patch }), async (specs: readonly any[]) => {
+					return specs.map(spec => {
+						const d = spec.doctype.toLowerCase()
+						const existing = getRecord(d, spec.id)
+						if (!existing) return null
+						if (d === 'project') {
+							const updated = { ...existing, ...spec.patch } as Project
+							projects.set(spec.id, updated)
+							return { data: updated, doctype: spec.doctype }
+						}
+						if (d === 'task') {
+							const updated = { ...existing, ...spec.patch } as Task
+							tasks.set(spec.id, updated)
+							return { data: updated, doctype: spec.doctype }
+						}
+						return null
+					})
+				})
+			},
 
-				return lambda(list([$doctype, $id]), ([doctype, id]) => {
-					console.log('stonecropDelete called:', { doctype, id })
-					return {
-						success: true,
-						data: { id },
-						error: null,
-					}
+			stonecropDelete(_: unknown, { $doctype, $id }: any) {
+				return loadOne(object({ doctype: $doctype, id: $id }), async (specs: readonly any[]) => {
+					return specs.map(spec => {
+						const d = spec.doctype.toLowerCase()
+						let deleted = false
+						if (d === 'project') deleted = projects.delete(spec.id)
+						else if (d === 'task') deleted = tasks.delete(spec.id)
+						return {
+							success: deleted,
+							data: deleted ? { id: spec.id } : null,
+							error: deleted ? null : 'Record not found',
+						}
+					})
 				})
 			},
 		},

package/templates/schema.graphql

@@ -20,6 +20,27 @@ type StonecropField {
 	default: JSON
 	width: String
 	validation: JSON
+	component: String
+	align: String
+	edit: Boolean
+	hidden: Boolean
+	mask: String
+	precision: Int
+	scale: Int
+	mode: String
+}
+
+"""
+A single workflow action definition
+"""
+type WorkflowAction {
+	name: String!
+	label: String
+	handler: String
+	requiredFields: [String!]
+	allowedStates: [String!]
+	confirm: Boolean
+	args: JSON
 }
 
 """
@@ -27,7 +48,7 @@ Workflow metadata with states and actions
 """
 type WorkflowMeta {
 	states: [String!]
-	actions: JSON
+	actions: [WorkflowAction!]
 }
 
 """
@@ -54,6 +75,7 @@ type HealthStatus {
 type RecordResult {
 	data: JSON
 	doctype: String!
+	unknownLinks: [String!]
 }
 
 type RecordsResult {
@@ -83,6 +105,11 @@ type Query {
 	"""
 	getMeta(doctype: String!): DoctypeMeta
 
+	"""
+	Get metadata for a doctype (used by StonecropClient)
+	"""
+	stonecropMeta(doctype: String!): DoctypeMeta
+
 	"""
 	Get all registered doctype metadata
 	"""
@@ -91,7 +118,7 @@ type Query {
 	"""
 	Get a single record by doctype and ID
 	"""
-	stonecropRecord(doctype: String!, id: String!): RecordResult
+	stonecropRecord(doctype: String!, id: String!, options: JSON): RecordResult
 
 	"""
 	Get multiple records with optional filtering

package/templates/stonecrop.client.ts

@@ -0,0 +1,42 @@
+import { StonecropClient } from '@stonecrop/graphql-client'
+import { Doctype } from '@stonecrop/stonecrop'
+
+import { doctypeMap } from '~/composables/useDoctypes'
+
+export default defineNuxtPlugin({
+	name: 'stonecrop-client',
+	dependsOn: ['stonecrop'],
+	setup() {
+		const { registerClient, registerMeta, registry } = useStonecropSetup()
+
+		const client = new StonecropClient({
+			endpoint: '/graphql/',
+		})
+
+		registerClient(client)
+
+		registerMeta(async routeContext => {
+			const slug = routeContext.segments?.[0] ?? ''
+			if (!slug) throw new Error('Cannot resolve doctype from route context')
+
+			const localDoctype = doctypeMap.get(slug)
+			if (!localDoctype) throw new Error(`No doctype registered for slug: ${slug}`)
+
+			return Doctype.fromObject(localDoctype)
+		})
+
+		for (const [slug, doctypeConfig] of doctypeMap.entries()) {
+			const doctypeInstance = Doctype.fromObject(doctypeConfig)
+			registry!.addDoctype(doctypeInstance)
+			if (slug !== doctypeInstance.slug) {
+				registry!.registry[slug] = doctypeInstance
+			}
+		}
+
+		return {
+			provide: {
+				stonecropClient: client,
+			},
+		}
+	},
+})

package/templates/stonecrop.ts

@@ -0,0 +1,82 @@
+/**
+ * Stonecrop Server Plugin
+ *
+ * Runs at server startup (Nitro plugin) to:
+ * 1. Load doctype definitions from the doctypes/ directory
+ * 2. Register built-in action handlers (validation, etc.)
+ * 3. Register custom workflow action handlers
+ *
+ * Action handlers receive (args, context) where args is the array sent by the
+ * client — the app's frontend (app/composables/useDoctypes.ts) sends a single
+ * `{ id, data? }` object per action — and context.doctype is the DoctypeMeta
+ * for the doctype being acted upon. For this in-memory setup, data is imported
+ * directly from server/data.ts. In production with PostGraphile, context.pgClient
+ * provides an active database connection instead — see:
+ * https://stonecrop.io/docs/guides/postgraphile
+ */
+
+import { resolve } from 'node:path'
+import { clearRegistry, loadDoctypes, registerBuiltinHandlers, registerHandler } from '@stonecrop/graphql-middleware'
+import { projects, tasks, type Project, type Task } from '../data'
+
+/** Action argument shape sent by the frontend (see runDoctypeAction in useDoctypes.ts) */
+type ActionArgs = [{ id: string; data?: Record<string, unknown> }]
+
+export default defineNitroPlugin(async () => {
+	clearRegistry()
+
+	const doctypesDir = resolve(process.cwd(), 'doctypes')
+	loadDoctypes(doctypesDir, { continueOnError: true })
+
+	registerBuiltinHandlers()
+
+	// Persist form edits to a Project
+	registerHandler('project:save', async (args: unknown[]) => {
+		const [{ id, data }] = args as ActionArgs
+		const project = projects.get(id)
+		if (!project) throw new Error(`Project not found: ${id}`)
+		const updated = { ...project, ...data, id } as Project
+		projects.set(id, updated)
+		return updated
+	})
+
+	// Persist form edits to a Task
+	registerHandler('task:save', async (args: unknown[]) => {
+		const [{ id, data }] = args as ActionArgs
+		const task = tasks.get(id)
+		if (!task) throw new Error(`Task not found: ${id}`)
+		const updated = { ...task, ...data, id } as Task
+		tasks.set(id, updated)
+		return updated
+	})
+
+	// Transition a Task from Todo → In Progress
+	registerHandler('start_task', async (args: unknown[]) => {
+		const [{ id }] = args as ActionArgs
+		const task = tasks.get(id)
+		if (!task) throw new Error(`Task not found: ${id}`)
+		const updated = { ...task, status: 'In Progress' as const }
+		tasks.set(id, updated)
+		return updated
+	})
+
+	// Transition a Task from In Progress → Done
+	registerHandler('complete_task', async (args: unknown[]) => {
+		const [{ id }] = args as ActionArgs
+		const task = tasks.get(id)
+		if (!task) throw new Error(`Task not found: ${id}`)
+		const updated = { ...task, status: 'Done' as const }
+		tasks.set(id, updated)
+		return updated
+	})
+
+	// Transition a Project from Active → Archived
+	registerHandler('archive_project', async (args: unknown[]) => {
+		const [{ id }] = args as ActionArgs
+		const project = projects.get(id)
+		if (!project) throw new Error(`Project not found: ${id}`)
+		const updated = { ...project, status: 'Archived' as const }
+		projects.set(id, updated)
+		return updated
+	})
+})