@narrative.io/jsonforms-provider-protocols 3.0.0-beta.2 → 3.0.0-beta.20

package/src/core/resolveScope.ts

@@ -1,3 +1,5 @@
+import { deepDeref, deref, tryCombinatorBranches } from "./refs";
+
 /**
  * Resolve a JSON Forms scope path to its schema within a root schema.
  * Handles nested paths like "#/properties/parent/properties/child".
@@ -6,6 +8,12 @@
  *   - "properties" segments navigate into object `.properties`
  *   - "items" segments navigate into array `.items`
  *   - all other segments index directly into the current object
+ *
+ * Dereferences `$ref` nodes transparently at every step, and falls through
+ * to `oneOf` / `anyOf` / `allOf` branches when a segment can't resolve
+ * directly — picks the first branch that satisfies the navigation. The
+ * returned schema is deep-dereferenced so downstream walkers can operate on
+ * a self-contained sub-schema without needing the original root.
  */
 export function resolveScopeSchema(
   scope: string,
@@ -17,23 +25,30 @@ export function resolveScopeSchema(
 
   // Remove the leading "#/" and split into segments
   const path = scope.replace(/^#\/?/, "");
-  if (!path) return rootSchema;
+  if (!path) return deepDeref(rootSchema, rootSchema);
 
   const segments = path.split("/");
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let current: any = rootSchema;
 
   for (const segment of segments) {
+    current = deref(current, rootSchema);
     if (!current || typeof current !== "object") return undefined;
 
-    if (segment === "properties") {
-      current = current.properties;
-    } else if (segment === "items") {
-      current = current.items;
-    } else {
-      current = current[segment];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const navigate = (node: Record<string, any>): unknown => {
+      if (segment === "properties") return node.properties;
+      if (segment === "items") return node.items;
+      return node[segment];
+    };
+
+    let next = navigate(current);
+    if (next === undefined) {
+      next = tryCombinatorBranches(current, rootSchema, navigate);
     }
+    if (next === undefined) return undefined;
+    current = next;
   }
 
-  return current;
+  return deepDeref(current, rootSchema);
 }

package/src/core/transforms.ts

@@ -14,7 +14,16 @@ export interface FlattenTransform extends Transform {
   labelFormat?: string; // Optional format string like "{parent.name} → {name}"
 }
 
-export type FilterOperator = "eq" | "neq" | "empty" | "notEmpty" | "gt" | "gte" | "lt" | "lte" | "contains";
+export type FilterOperator =
+  | "eq"
+  | "neq"
+  | "empty"
+  | "notEmpty"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "contains";
 
 export interface FilterCondition {
   key: string;
@@ -153,13 +162,29 @@ function evaluateCondition(
     case "notEmpty":
       return !isEmpty(value);
     case "gt":
-      return typeof value === "number" && condition.values !== undefined && value > (condition.values[0] as number);
+      return (
+        typeof value === "number" &&
+        condition.values !== undefined &&
+        value > (condition.values[0] as number)
+      );
     case "gte":
-      return typeof value === "number" && condition.values !== undefined && value >= (condition.values[0] as number);
+      return (
+        typeof value === "number" &&
+        condition.values !== undefined &&
+        value >= (condition.values[0] as number)
+      );
     case "lt":
-      return typeof value === "number" && condition.values !== undefined && value < (condition.values[0] as number);
+      return (
+        typeof value === "number" &&
+        condition.values !== undefined &&
+        value < (condition.values[0] as number)
+      );
     case "lte":
-      return typeof value === "number" && condition.values !== undefined && value <= (condition.values[0] as number);
+      return (
+        typeof value === "number" &&
+        condition.values !== undefined &&
+        value <= (condition.values[0] as number)
+      );
     case "contains":
       if (typeof value === "string" && condition.values) {
         return condition.values.some((v) => value.includes(String(v)));
@@ -208,7 +233,9 @@ function filterTransform(items: unknown[], config: Transform): unknown[] {
   return items.filter((item) => {
     if (typeof item !== "object" || item === null) return false;
     const itemObj = item as Record<string, unknown>;
-    return conditions.every((condition) => evaluateCondition(itemObj, condition));
+    return conditions.every((condition) =>
+      evaluateCondition(itemObj, condition),
+    );
   });
 }
 

package/src/core/types.ts

@@ -51,4 +51,5 @@ export interface ConnectorDataLayer {
   dataset_id?: number;
   profile_id?: string;
   profile_name?: string;
+  datasetWriteMode?: "append" | "overwrite";
 }

package/src/index.ts

@@ -3,8 +3,6 @@ import { cache as globalCache } from "./core/cache";
 import { registry as globalRegistry } from "./core/registry";
 import type { Protocol, AuthConfig } from "./core/types";
 
-console.log("[jsonforms-provider-protocols] loaded v2.10.0 (symlink)");
-
 export { cache } from "./core/cache";
 export * from "./core/jsonpath";
 export { registry } from "./core/registry";
@@ -14,10 +12,24 @@ export * from "./core/projection";
 export * from "./core/resolveScope";
 // Core exports
 export * from "./core/types";
+export { initFormDataFromSchema } from "./core/initFormData";
 
 // Protocol exports
 export { RestApiProtocol } from "./protocols/rest_api";
 
+// CSP-safe validator
+export {
+  createNoEvalAjv,
+  transformUnit,
+  transformErrors,
+} from "./no-eval-ajv";
+export type {
+  NoEvalAjv,
+  NoEvalErrorObject,
+  NoEvalValidateFunction,
+  CreateNoEvalAjvOptions,
+} from "./no-eval-ajv";
+
 // Vue exports - using named imports to avoid potential bundling issues
 export {
   providerRenderers,

package/src/no-eval-ajv.ts

@@ -0,0 +1,381 @@
+import {
+  Validator,
+  type OutputUnit,
+  type Schema,
+  type SchemaDraft,
+} from "@cfworker/json-schema";
+
+/**
+ * CSP-safe JSON Schema validation backed by `@cfworker/json-schema`.
+ *
+ * Cloudflare Pages and similar strict-CSP environments forbid `new Function`,
+ * which is how AJV compiles validators. This factory returns an
+ * AJV-shaped facade whose `compile()` produces a synchronous validator
+ * function `(data) => boolean` with a mutable `errors` property — enough
+ * for `<JsonForms :ajv="..." />` to drop in without any other changes.
+ *
+ * Only `compile()` is functional; the rest of the surface (`addSchema`,
+ * `getSchema`, `removeSchema`, `addFormat`, `addKeyword`, `opts`) exists
+ * as no-ops for forward compatibility with plugins that probe the AJV
+ * interface but never reach those methods at runtime.
+ */
+
+// AJV's ErrorObject shape. We don't import `ajv` here to keep the lib's
+// zero-runtime-deps philosophy intact; the consumer's transitive AJV types
+// are structurally compatible.
+export interface NoEvalErrorObject {
+  instancePath: string;
+  schemaPath: string;
+  keyword: string;
+  params: Record<string, unknown>;
+  message?: string;
+}
+
+export interface NoEvalValidateFunction {
+  (data: unknown): boolean;
+  errors: NoEvalErrorObject[] | null;
+}
+
+// Minimal subset of AJV's surface that JsonForms touches. The factory
+// returns this as `unknown as Ajv` at the call site; consumers cast on
+// import or pass directly to `<JsonForms :ajv="..." />`.
+export interface NoEvalAjv {
+  compile: (schema: unknown) => NoEvalValidateFunction;
+  addSchema: (schema: unknown, key?: string) => NoEvalAjv;
+  getSchema: (key: string) => NoEvalValidateFunction | undefined;
+  removeSchema: (schemaKeyRef?: unknown) => NoEvalAjv;
+  addFormat: (name: string, format: unknown) => NoEvalAjv;
+  addKeyword: (definition: unknown) => NoEvalAjv;
+  opts: Readonly<Record<string, unknown>>;
+}
+
+export interface CreateNoEvalAjvOptions {
+  /**
+   * JSON Schema draft to validate against. Defaults to `'2020-12'` to match
+   * the spec; schemas authored against draft-07 should pass `'7'`.
+   */
+  draft?: SchemaDraft;
+}
+
+const KEYWORD_WRAPPERS = new Set([
+  "properties",
+  "items",
+  "prefixItems",
+  "$ref",
+]);
+
+const QUOTED_RE = /(['"])((?:\\.|(?!\1).)*?)\1/g;
+
+function findQuoted(s: string): string[] {
+  const out: string[] = [];
+  let m: RegExpExecArray | null;
+  QUOTED_RE.lastIndex = 0;
+  while ((m = QUOTED_RE.exec(s)) !== null) {
+    out.push(m[2]!);
+  }
+  return out;
+}
+
+function firstQuoted(s: string): string | undefined {
+  const all = findQuoted(s);
+  return all[0];
+}
+
+function allQuoted(s: string): string[] {
+  return findQuoted(s);
+}
+
+const NUMBER_RE = /-?\d+(?:\.\d+)?/g;
+
+function extractNumbers(s: string): number[] {
+  const out: number[] = [];
+  let m: RegExpExecArray | null;
+  NUMBER_RE.lastIndex = 0;
+  while ((m = NUMBER_RE.exec(s)) !== null) {
+    out.push(Number(m[0]));
+  }
+  return out;
+}
+
+function firstNumber(s: string): number | undefined {
+  const nums = extractNumbers(s);
+  return nums[0];
+}
+
+function stripPointerPrefix(p: string): string {
+  return p.startsWith("#") ? p.slice(1) : p;
+}
+
+interface KeywordTransform {
+  params: Record<string, unknown>;
+  message: string | undefined;
+}
+
+function transformByKeyword(unit: OutputUnit): KeywordTransform {
+  const { keyword, error } = unit;
+
+  switch (keyword) {
+    case "required": {
+      const prop = firstQuoted(error);
+      return {
+        params: { missingProperty: prop ?? "" },
+        message: prop
+          ? `must have required property '${prop}'`
+          : "must have required property",
+      };
+    }
+
+    case "type": {
+      const quoted = allQuoted(error);
+      // cfworker emits `Instance type "X" is invalid. Expected "Y".` (single)
+      // or `... Expected "Y" or "Z".` (union). Per AJV: `params.type` is the
+      // expected type as a string; for unions it's comma-separated.
+      const expected = quoted.slice(1).join(",") || quoted[0];
+      const message = expected ? `must be ${expected}` : "must be of expected type";
+      return {
+        params: expected ? { type: expected } : {},
+        message,
+      };
+    }
+
+    case "enum": {
+      // cfworker error: `Instance does not match any of [...].`
+      const match = error.match(/\[.*\]/);
+      let allowedValues: unknown[] = [];
+      if (match) {
+        try {
+          allowedValues = JSON.parse(match[0]);
+        } catch {
+          allowedValues = [];
+        }
+      }
+      return {
+        params: { allowedValues },
+        message: "must be equal to one of the allowed values",
+      };
+    }
+
+    case "const":
+      return {
+        params: {},
+        message: "must be equal to constant",
+      };
+
+    case "minimum": {
+      const limit = extractNumbers(error)[1];
+      return {
+        params: { comparison: ">=", limit: limit ?? 0 },
+        message: `must be >= ${limit ?? 0}`,
+      };
+    }
+
+    case "exclusiveMinimum": {
+      const limit = extractNumbers(error)[1];
+      return {
+        params: { comparison: ">", limit: limit ?? 0 },
+        message: `must be > ${limit ?? 0}`,
+      };
+    }
+
+    case "maximum": {
+      const limit = extractNumbers(error)[1];
+      return {
+        params: { comparison: "<=", limit: limit ?? 0 },
+        message: `must be <= ${limit ?? 0}`,
+      };
+    }
+
+    case "exclusiveMaximum": {
+      const limit = extractNumbers(error)[1];
+      return {
+        params: { comparison: "<", limit: limit ?? 0 },
+        message: `must be < ${limit ?? 0}`,
+      };
+    }
+
+    case "minLength": {
+      const limit = firstNumber(error) ?? 0;
+      return {
+        params: { limit },
+        message: `must NOT have fewer than ${limit} characters`,
+      };
+    }
+
+    case "maxLength": {
+      const limit = firstNumber(error) ?? 0;
+      return {
+        params: { limit },
+        message: `must NOT have more than ${limit} characters`,
+      };
+    }
+
+    case "minItems": {
+      const limit = firstNumber(error) ?? 0;
+      return {
+        params: { limit },
+        message: `must NOT have fewer than ${limit} items`,
+      };
+    }
+
+    case "maxItems": {
+      const limit = firstNumber(error) ?? 0;
+      return {
+        params: { limit },
+        message: `must NOT have more than ${limit} items`,
+      };
+    }
+
+    case "pattern": {
+      const pattern = firstQuoted(error) ?? "";
+      return {
+        params: { pattern },
+        message: `must match pattern "${pattern}"`,
+      };
+    }
+
+    case "format": {
+      const format = firstQuoted(error) ?? "";
+      return {
+        params: { format },
+        message: `must match format "${format}"`,
+      };
+    }
+
+    case "multipleOf": {
+      // cfworker emits two numbers: the value and the divisor.
+      const nums = extractNumbers(error);
+      const multipleOf = nums[1] ?? nums[0] ?? 1;
+      return {
+        params: { multipleOf },
+        message: `must be multiple of ${multipleOf}`,
+      };
+    }
+
+    case "uniqueItems":
+      return {
+        params: {},
+        message: "must NOT have duplicate items",
+      };
+
+    case "additionalProperties": {
+      const additionalProperty = firstQuoted(error) ?? "";
+      return {
+        params: { additionalProperty },
+        message: `must NOT have additional property '${additionalProperty}'`,
+      };
+    }
+
+    case "anyOf":
+      return { params: {}, message: "must match a schema in anyOf" };
+
+    case "oneOf":
+      return {
+        params: { passingSchemas: null },
+        message: "must match exactly one schema in oneOf",
+      };
+
+    case "allOf":
+      return { params: {}, message: "must match all schemas in allOf" };
+
+    case "not":
+      return { params: {}, message: "must NOT be valid against schema" };
+
+    default:
+      return { params: {}, message: undefined };
+  }
+}
+
+/**
+ * Transform a single cfworker `OutputUnit` into an AJV-compatible
+ * `ErrorObject`, or `null` if the unit is a structural wrapper that should
+ * be filtered out (`properties` / `items` / `prefixItems` / `$ref`).
+ *
+ * Exported for unit testing.
+ */
+export function transformUnit(unit: OutputUnit): NoEvalErrorObject | null {
+  if (KEYWORD_WRAPPERS.has(unit.keyword)) return null;
+
+  const { params, message } = transformByKeyword(unit);
+
+  return {
+    instancePath: stripPointerPrefix(unit.instanceLocation),
+    schemaPath: unit.keywordLocation,
+    keyword: unit.keyword,
+    params,
+    message: message ?? unit.error,
+  };
+}
+
+/**
+ * Transform a cfworker `OutputUnit[]` into an AJV-compatible
+ * `ErrorObject[]`, with structural wrappers filtered out.
+ *
+ * Exported for unit testing.
+ */
+export function transformErrors(units: OutputUnit[]): NoEvalErrorObject[] {
+  const out: NoEvalErrorObject[] = [];
+  for (const unit of units) {
+    const transformed = transformUnit(unit);
+    if (transformed !== null) out.push(transformed);
+  }
+  return out;
+}
+
+const FROZEN_OPTS: Readonly<Record<string, unknown>> = Object.freeze({
+  allErrors: true,
+  verbose: true,
+  errorDataPath: "",
+  strict: false,
+});
+
+/**
+ * Build a CSP-safe AJV-shaped validator backed by `@cfworker/json-schema`.
+ *
+ * Each `compile(schema)` call constructs a `Validator` and returns a
+ * synchronous validator function. The validator function's `errors`
+ * property is reassigned on every call, matching AJV's contract.
+ *
+ * Validators are memoized per-schema via a `WeakMap`, so JsonForms's
+ * repeated `compile()` calls on prop changes don't re-parse the schema
+ * graph each time.
+ */
+export function createNoEvalAjv(
+  options: CreateNoEvalAjvOptions = {},
+): NoEvalAjv {
+  const draft: SchemaDraft = options.draft ?? "2020-12";
+  const cache = new WeakMap<object, NoEvalValidateFunction>();
+
+  const compile = (schema: unknown): NoEvalValidateFunction => {
+    if (schema && typeof schema === "object") {
+      const cached = cache.get(schema as object);
+      if (cached) return cached;
+    }
+
+    const validator = new Validator(schema as Schema | boolean, draft, false);
+
+    const fn: NoEvalValidateFunction = ((data: unknown) => {
+      const result = validator.validate(data);
+      fn.errors = result.valid ? null : transformErrors(result.errors);
+      return result.valid;
+    }) as NoEvalValidateFunction;
+
+    fn.errors = null;
+
+    if (schema && typeof schema === "object") {
+      cache.set(schema as object, fn);
+    }
+    return fn;
+  };
+
+  const facade: NoEvalAjv = {
+    compile,
+    addSchema: () => facade,
+    getSchema: () => undefined,
+    removeSchema: () => facade,
+    addFormat: () => facade,
+    addKeyword: () => facade,
+    opts: FROZEN_OPTS,
+  };
+
+  return facade;
+}

package/src/vue/components/ProviderAutocomplete.vue

@@ -12,7 +12,11 @@ const props = defineProps<{
   path: string;
 }>();
 const { control, handleChange: rawHandleChange } = useJsonFormsControl(props);
-const { projectedData, handleProjectedChange: handleChange } = useProjection(control, rawHandleChange);
+const {
+  projectedData,
+  projectedLabel,
+  handleProjectedChange: handleChange,
+} = useProjection(control, rawHandleChange);
 
 const binding = computed(() => {
   const provider = control.value.uischema?.options?.provider;
@@ -53,16 +57,14 @@ const onSelect = (event: { value?: { value?: unknown } | unknown }) => {
 </script>
 
 <template>
-  <div class="flex flex-column gap-1">
-    <label v-if="control.schema.title" class="text-color text-left">{{
-      control.schema.title
-    }}</label>
-    <div v-if="control.description" class="text-color-secondary text-left">
+  <div class="jf-control">
+    <label v-if="projectedLabel" class="jf-label">{{ projectedLabel }}</label>
+    <div v-if="control.description" class="jf-description">
       {{ control.description }}
     </div>
     <AutoComplete
       v-model="value"
-      class="w-full"
+      class="w-full!"
       :suggestions="items"
       option-label="label"
       :placeholder="placeholder"

package/src/vue/components/ProviderMultiSelect.vue

@@ -5,6 +5,7 @@ import { computed, inject, watch } from "vue";
 import { useProvider } from "../composables/useProvider";
 import { useProjection } from "../composables/useProjection";
 import { shouldAutoSelectMulti } from "../utils/autoSelect";
+import { resolvePlaceholder } from "../utils/placeholder";
 import MultiSelect from "primevue/multiselect";
 
 const props = defineProps<{
@@ -13,7 +14,11 @@ const props = defineProps<{
   path: string;
 }>();
 const { control, handleChange: rawHandleChange } = useJsonFormsControl(props);
-const { projectedData, handleProjectedChange: handleChange } = useProjection(control, rawHandleChange);
+const {
+  projectedData,
+  projectedLabel,
+  handleProjectedChange: handleChange,
+} = useProjection(control, rawHandleChange);
 
 const binding = computed(() => {
   const provider = control.value.uischema?.options?.provider;
@@ -41,7 +46,7 @@ const rootData = computed(() => injectedFormData.value || {});
 const { items, loading, error } = useProvider(binding, {
   data: rootData, // Pass the reactive reference
   path: control.value.path,
-  dependsOnValues: depValues.value,
+  dependsOnValues: depValues,
 });
 
 // Provider will automatically reload when rootData changes due to reactive cache key
@@ -55,14 +60,16 @@ watch(
         control.value.uischema?.options?.autoSelectSingle === true,
       isLoading,
       items: newItems,
-      currentValue: Array.isArray(projectedData.value) ? projectedData.value : [],
+      currentValue: Array.isArray(projectedData.value)
+        ? projectedData.value
+        : [],
     });
 
     if (valueToSelect !== null) {
       handleChange(control.value.path, valueToSelect);
     }
   },
-  { immediate: true }
+  { immediate: true },
 );
 
 // order-insensitive shallow equality for primitive arrays
@@ -89,25 +96,23 @@ const value = computed({
 
 const placeholder = computed(() => {
   if (loading.value) return "Loading…";
-  // Check for placeholder in uischema options
-  const uischemaPlaceholder = (
-    control.value.uischema as { options?: { placeholder?: string } }
-  )?.options?.placeholder;
-  return uischemaPlaceholder || "Select…";
+  return resolvePlaceholder(
+    control.value.uischema,
+    projectedLabel.value,
+    "select",
+  );
 });
 </script>
 
 <template>
-  <div class="flex flex-column gap-2">
-    <label v-if="control.schema.title" class="text-color text-left">{{
-      control.schema.title
-    }}</label>
-    <div v-if="control.description" class="text-color-secondary text-left">
+  <div class="jf-control">
+    <label v-if="projectedLabel" class="jf-label">{{ projectedLabel }}</label>
+    <div v-if="control.description" class="jf-description">
       {{ control.description }}
     </div>
     <MultiSelect
       v-model="value"
-      class="w-full"
+      class="w-full!"
       :options="items"
       option-label="label"
       option-value="value"