@stonecrop/nuxt 0.7.3 → 0.7.5

package/templates/plugins.ts

@@ -0,0 +1,81 @@
+/**
+ * Grafserv Plugins
+ * Add custom middleware and hooks via Grafserv plugins
+ *
+ * @see https://grafast.org/grafserv/plugins
+ */
+
+import type { GraphileConfig } from 'graphile-config'
+
+/**
+ * Example: Request logging plugin
+ */
+const loggingPlugin: GraphileConfig.Plugin = {
+	name: 'request-logging',
+	version: '1.0.0',
+	grafserv: {
+		middleware: {
+			processGraphQLRequestBody: async (next, event) => {
+				const start = Date.now()
+				console.log('[GraphQL] Request started:', {
+					path: event.request.url,
+					method: event.request.method,
+				})
+
+				const result = await next()
+
+				const duration = Date.now() - start
+				console.log(`[GraphQL] Request completed in ${duration}ms`)
+
+				return result
+			},
+		},
+	},
+}
+
+/**
+ * Example: Authentication plugin
+ */
+const authPlugin: GraphileConfig.Plugin = {
+	name: 'authentication',
+	version: '1.0.0',
+	grafserv: {
+		middleware: {
+			processGraphQLRequestBody: async (next, event) => {
+				// Extract authentication from headers
+				const authHeader = event.request.headers.get('authorization')
+
+				if (authHeader?.startsWith('Bearer ')) {
+					const token = authHeader.slice(7)
+					// TODO: Validate token and set user context
+					console.log('[Auth] Token received:', token)
+				} else {
+					console.log('[Auth] Anonymous request')
+				}
+
+				return next()
+			},
+		},
+	},
+}
+
+/**
+ * Export all plugins
+ * Import these in your nuxt.config.ts:
+ *
+ * import plugins from './server/plugins'
+ *
+ * export default defineNuxtConfig({
+ *   grafserv: {
+ *     preset: {
+ *       plugins
+ *     }
+ *   }
+ * })
+ */
+export const plugins: GraphileConfig.Plugin[] = [
+	loggingPlugin,
+	// authPlugin, // Uncomment to enable authentication
+]
+
+export default plugins

package/templates/resolvers.ts

@@ -0,0 +1,256 @@
+/**
+ * Stonecrop GraphQL Resolvers
+ *
+ * This file contains resolver implementations for the Stonecrop GraphQL schema.
+ * Customize these resolvers to connect to your data sources.
+ *
+ * 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
+ *
+ * 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!
+ */
+
+// Import Grafast step functions
+// IMPORTANT: Must import from 'grafast' not 'postgraphile/grafast' for Nitro bundling
+import { constant, lambda, list } from 'grafast'
+
+// Import Stonecrop middleware for doctype metadata
+// import { getMeta, getAllMeta } from '@stonecrop/graphql-middleware'
+
+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',
+				})
+			},
+
+			/**
+			 * 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
+				// 		})
+				// 	)
+				// })
+
+				return lambda($doctype, doctype => {
+					console.log('getMeta called for:', doctype)
+					return 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([])
+			},
+
+			/**
+			 * 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,
+					}
+				})
+			},
+
+			/**
+			 * Get multiple records with filtering
+			 */
+			stonecropRecords(_$parent, { $doctype, $filters, $orderBy, $limit, $offset }) {
+				// 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]),
+					([doctype, filters, orderBy, limit, offset]) => {
+						console.log('stonecropRecords called:', { doctype, filters, orderBy, limit, offset })
+						return {
+							data: [],
+							doctype,
+							count: 0,
+						}
+					}
+				)
+			},
+		},
+	},
+
+	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
+
+				// 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 }
+				// 		})
+				// 	)
+				// })
+
+				return lambda(list([$doctype, $action, $args]), ([doctype, action, actionArgs]) => {
+					console.log('stonecropAction called:', { doctype, action, args: actionArgs })
+					return {
+						success: true,
+						data: null,
+						error: null,
+					}
+				})
+			},
+
+			/**
+			 * Create a new record
+			 */
+			stonecropCreate(_$parent, { $doctype, $input }) {
+				// Arguments come pre-destructured as steps with $ prefix
+
+				// 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,
+					}
+				})
+			},
+
+			/**
+			 * 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,
+					}
+				})
+			},
+
+			/**
+			 * 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 }
+				// 		})
+				// 	)
+				// })
+
+				return lambda(list([$doctype, $id]), ([doctype, id]) => {
+					console.log('stonecropDelete called:', { doctype, id })
+					return {
+						success: true,
+						data: { id },
+						error: null,
+					}
+				})
+			},
+		},
+	},
+}
+
+export default resolvers

package/templates/schema.graphql

@@ -0,0 +1,129 @@
+# Stonecrop GraphQL Schema
+# Add your type definitions here
+
+scalar JSON
+
+# ============================================
+# Stonecrop Meta Types
+# ============================================
+
+"""
+Field metadata from doctype schema
+"""
+type FieldMeta {
+	fieldname: String!
+	fieldtype: String!
+	label: String
+	required: Boolean
+	readOnly: Boolean
+	options: JSON
+	default: JSON
+	width: String
+	validation: JSON
+}
+
+"""
+Workflow metadata with states and actions
+"""
+type WorkflowMeta {
+	states: [String!]
+	actions: JSON
+}
+
+"""
+Complete doctype metadata
+"""
+type DoctypeMeta {
+	name: String!
+	slug: String
+	tableName: String
+	fields: [FieldMeta!]!
+	workflow: WorkflowMeta
+	inherits: String
+	listDoctype: String
+	parentDoctype: String
+}
+
+# ============================================
+# Result Types
+# ============================================
+
+type HealthStatus {
+	status: String!
+	timestamp: String!
+	version: String!
+}
+
+type RecordResult {
+	data: JSON
+	doctype: String!
+}
+
+type RecordsResult {
+	data: [JSON!]!
+	doctype: String!
+	count: Int!
+}
+
+type ActionResult {
+	success: Boolean!
+	data: JSON
+	error: String
+}
+
+# ============================================
+# Queries
+# ============================================
+
+type Query {
+	"""
+	Health check endpoint
+	"""
+	healthCheck: HealthStatus!
+
+	"""
+	Get metadata for a doctype
+	"""
+	getMeta(doctype: String!): DoctypeMeta
+
+	"""
+	Get all registered doctype metadata
+	"""
+	stonecropAllMeta: [DoctypeMeta!]!
+
+	"""
+	Get a single record by doctype and ID
+	"""
+	stonecropRecord(doctype: String!, id: String!): RecordResult
+
+	"""
+	Get multiple records with optional filtering
+	"""
+	stonecropRecords(doctype: String!, filters: JSON, orderBy: String, limit: Int, offset: Int): RecordsResult
+}
+
+# ============================================
+# Mutations
+# ============================================
+
+type Mutation {
+	"""
+	Execute a doctype action
+	"""
+	stonecropAction(doctype: String!, action: String!, args: JSON): ActionResult!
+
+	"""
+	Create a new record
+	"""
+	stonecropCreate(doctype: String!, input: JSON!): RecordResult!
+
+	"""
+	Update an existing record
+	"""
+	stonecropUpdate(doctype: String!, id: String!, patch: JSON!): RecordResult
+
+	"""
+	Delete a record
+	"""
+	stonecropDelete(doctype: String!, id: String!): ActionResult!
+}