feat: filter pubs using jsonata

core/app/c/[communitySlug]/stages/manage/components/panel/automationsTab/StagePanelAutomationForm.tsx

@@ -45,7 +45,9 @@ import { Input } from "ui/input"
 import { Item, ItemContent, ItemHeader } from "ui/item"
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "ui/select"
 import { FormSubmitButton } from "ui/submit-button"
+import { Textarea } from "ui/textarea"
 import { type TokenContext, TokenProvider } from "ui/tokens"
+import { Tooltip, TooltipContent, TooltipTrigger } from "ui/tooltip"
 import { cn } from "utils"
 
 import { ActionConfigBuilder } from "~/actions/_lib/ActionConfigBuilder"
@@ -386,62 +388,82 @@ const ResolverFieldSection = memo(
 		form: UseFormReturn<CreateAutomationsSchema>
 		resolver: string | null | undefined
 	}) {
+		const hasResolver = props.resolver !== undefined && props.resolver !== null
+
+		if (!hasResolver) {
+			return (
+				<Button
+					type="button"
+					variant="ghost"
+					size="sm"
+					className="h-8 p-0 text-muted-foreground text-xs"
+					onClick={() => props.form.setValue("resolver", "")}
+				>
+					<Plus size={14} />
+					Add resolver
+				</Button>
+			)
+		}
+
 		return (
 			<Controller
 				control={props.form.control}
 				name="resolver"
 				render={({ field, fieldState }) => (
-					<Field data-invalid={fieldState.invalid}>
-						<div className="flex items-center justify-between">
-							<FieldLabel>
-								Resolver (optional)
-								<InfoButton>
-									<p className="text-xs">
-										A JSONata expression to resolve a different Pub or transform
-										JSON input before actions run.
-										<br />
-										<br />
-										<strong>Comparison expressions</strong> like{" "}
-										<code>$.json.some.id = $.pub.values.fieldname</code> will
-										find a Pub where the field matches the left side value.
-										<br />
-										<br />
-										<strong>Transform expressions</strong> can restructure the
-										input data for the automation's actions.
-									</p>
-								</InfoButton>
-							</FieldLabel>
-							{props.resolver && (
-								<Button
-									type="button"
-									variant="ghost"
-									size="sm"
-									className="h-7 text-neutral-500 text-xs"
-									onClick={() => {
-										field.onChange(undefined)
-									}}
-								>
-									Remove resolver
-								</Button>
-							)}
+					<div>
+						<div className="mb-2 flex items-center justify-between">
+							<div className="flex items-center gap-2">
+								<Tooltip delayDuration={300}>
+									<TooltipTrigger asChild>
+										<span className="cursor-help rounded bg-amber-100 px-1.5 py-0.5 font-medium text-amber-800 text-xs">
+											Resolver
+										</span>
+									</TooltipTrigger>
+									<TooltipContent className="max-w-sm text-xs">
+										<p>
+											A JSONata expression to resolve a different Pub or
+											transform JSON input before actions run.
+										</p>
+										<p className="mt-2">
+											<strong>Query:</strong>{" "}
+											<code className="text-xs">
+												{"$.pub.values.externalId = {{ $.json.body.id }}"}
+											</code>
+										</p>
+										<p className="mt-1">
+											<strong>Transform:</strong>{" "}
+											<code className="text-xs">
+												{'{ "title": $.json.body.name }'}
+											</code>
+										</p>
+									</TooltipContent>
+								</Tooltip>
+							</div>
+							<Button
+								type="button"
+								variant="ghost"
+								size="sm"
+								className="h-6 p-1 text-muted-foreground hover:text-destructive"
+								onClick={() => field.onChange(undefined)}
+							>
+								<X size={14} />
+							</Button>
 						</div>
-						<Input
+						<Textarea
 							{...field}
 							value={field.value ?? ""}
-							placeholder="Enter JSONata expression (e.g., $.json.articleId = $.pub.values.externalId)"
+							placeholder="$.pub.values.externalId = {{ $.json.body.articleId }}"
 							className={cn(
-								"font-mono text-sm",
+								"min-h-[60px] border-amber-300 bg-white font-mono text-sm focus:border-amber-400 focus-visible:ring-amber-400 dark:bg-input/30 dark:text-white",
 								fieldState.invalid && "border-red-300"
 							)}
 						/>
-						<FieldDescription>
-							Use a JSONata expression to resolve a Pub by comparing values, e.g.,{" "}
-							<code>$.json.id = $.pub.values.externalId</code>
-						</FieldDescription>
 						{fieldState.error && (
-							<FieldError className="text-xs">{fieldState.error.message}</FieldError>
+							<p className="mt-1 text-destructive text-xs">
+								{fieldState.error.message}
+							</p>
 						)}
-					</Field>
+					</div>
 				)}
 			/>
 		)

core/lib/server/jsonata-query/SYNTAX.md

@@ -0,0 +1,194 @@
+# JSONata Query Syntax
+
+Query language for filtering pubs. Based on JSONata with restrictions.
+
+## Paths
+
+### Pub field values
+
+```
+$.pub.values.title
+$.pub.values.externalId
+```
+
+### Builtin fields
+
+```
+$.pub.id
+$.pub.createdAt
+$.pub.updatedAt
+$.pub.pubTypeId
+$.pub.title
+$.pub.stageId
+```
+
+### Pub type
+
+```
+$.pub.pubType.name
+$.pub.pubType.id
+```
+
+## Comparison operators
+
+### Equality
+
+```
+$.pub.values.title = "Test"
+$.pub.values.count != 0
+```
+
+### Numeric comparison
+
+```
+$.pub.values.count > 10
+$.pub.values.count >= 10
+$.pub.values.count < 100
+$.pub.values.count <= 100
+```
+
+### In array
+
+```
+$.pub.values.status in ["draft", "published"]
+```
+
+## Logical operators
+
+### And
+
+```
+$.pub.values.status = "published" and $.pub.values.count > 0
+```
+
+### Or
+
+```
+$.pub.values.status = "draft" or $.pub.values.status = "pending"
+```
+
+### Not
+
+```
+$not($.pub.values.archived = true)
+```
+
+## String functions
+
+### Contains
+
+```
+$contains($.pub.values.title, "chapter")
+```
+
+### Starts with
+
+```
+$startsWith($.pub.values.title, "Introduction")
+```
+
+### Ends with
+
+```
+$endsWith($.pub.values.filename, ".pdf")
+```
+
+## Case-insensitive matching
+
+Wrap the path in `$lowercase()` or `$uppercase()`.
+
+### Case-insensitive contains
+
+```
+$contains($lowercase($.pub.values.title), "snap")
+```
+
+### Case-insensitive equality
+
+```
+$lowercase($.pub.values.status) = "draft"
+```
+
+## Existence check
+
+```
+$exists($.pub.values.optionalField)
+```
+
+## Full-text search
+
+Searches across all pub values using PostgreSQL full-text search.
+
+```
+$search("climate change")
+```
+
+## Relations
+
+### Outgoing relations
+
+Find pubs that have outgoing relations via a field.
+
+```
+$.pub.out.contributors
+```
+
+### Outgoing relations with filter
+
+Filter by the relation value.
+
+```
+$.pub.out.contributors[$.value = "Editor"]
+```
+
+Filter by the related pub's field.
+
+```
+$.pub.out.contributors[$.relatedPub.values.institution = "MIT"]
+```
+
+Filter by the related pub's type.
+
+```
+$.pub.out.contributors[$.relatedPub.pubType.name = "Author"]
+```
+
+Combined filters.
+
+```
+$.pub.out.contributors[$.value = "Editor" and $contains($.relatedPub.values.name, "Smith")]
+```
+
+### Incoming relations
+
+Find pubs that are referenced by other pubs via a field.
+
+```
+$.pub.in.chapters
+```
+
+Filter by the source pub.
+
+```
+$.pub.in.chapters[$.relatedPub.values.title = "The Big Book"]
+```
+
+## Interpolation (resolver only)
+
+At the moment only used when configuring automations.
+
+Use `{{ }}` to interpolate values from the context when using as a resolver.
+
+```
+$.pub.values.externalId = {{ $.json.body.articleId }}
+```
+
+The expression inside `{{ }}` is evaluated against the automation context before the query runs.
+
+## Limits
+
+Maximum relation depth: 3 levels.
+
+## Unsupported
+
+Variable assignment, lambda functions, recursive descent, and other advanced JSONata features are not supported.

core/lib/server/jsonata-query/compiler.ts

@@ -0,0 +1,20 @@
+import type { ParsedCondition } from "./parser"
+
+import { parseJsonataQuery } from "./parser"
+
+export interface CompiledQuery {
+	condition: ParsedCondition
+	originalExpression: string
+}
+
+/**
+ * compiles a jsonata expression into a query that can be used for
+ * both sql generation and in-memory filtering
+ */
+export function compileJsonataQuery(expression: string): CompiledQuery {
+	const parsed = parseJsonataQuery(expression)
+	return {
+		condition: parsed.condition,
+		originalExpression: expression,
+	}
+}

core/lib/server/jsonata-query/errors.ts

@@ -0,0 +1,31 @@
+export class JsonataQueryError extends Error {
+	constructor(
+		message: string,
+		public readonly expression?: string
+	) {
+		super(message)
+		this.name = "JsonataQueryError"
+	}
+}
+
+export class UnsupportedExpressionError extends JsonataQueryError {
+	constructor(
+		message: string,
+		public readonly nodeType?: string,
+		expression?: string
+	) {
+		super(message, expression)
+		this.name = "UnsupportedExpressionError"
+	}
+}
+
+export class InvalidPathError extends JsonataQueryError {
+	constructor(
+		message: string,
+		public readonly path?: string,
+		expression?: string
+	) {
+		super(message, expression)
+		this.name = "InvalidPathError"
+	}
+}