@narrative.io/jsonforms-provider-protocols 2.11.0 → 2.12.0

package/src/core/seedProjectionTargets.ts

@@ -0,0 +1,144 @@
+import {
+  getProjectedValue,
+  parseProjectionPath,
+  setProjectedValue,
+} from "./projection";
+
+/**
+ * Materialize array indices targeted by `options.projection` controls in a
+ * UI schema, so that JSON Schema validators (AJV / cfworker) emit
+ * `items.required` errors on otherwise-empty arrays.
+ *
+ * Why this exists:
+ *   `initFormDataFromSchema` omits optional fields, so an optional array
+ *   like `data_rates: { type: 'array', items: { $ref: '#/$defs/DataRate' } }`
+ *   produces `undefined` (or, historically, `[]`). Both shapes pass schema
+ *   validation: `undefined` doesn't trigger `type: array`, and `[]` has no
+ *   items to apply `items.required` to. As a result, a projection-targeted
+ *   field rendered with `Video CPM rate *` lies — the asterisk says
+ *   "required" but the validator never enforces it on an untouched form.
+ *
+ *   This utility opts the consumer into per-item enforcement by walking the
+ *   UI schema, finding every `Control` with `options.projection` that
+ *   addresses an array index, and ensuring the corresponding data path has
+ *   that index materialized as at least `{}`. With the empty object in
+ *   place, the schema's `items.required` fires and the projected control's
+ *   error string surfaces at form-validity time.
+ *
+ * Tradeoff:
+ *   This re-introduces "noise" on untouched forms — required-field errors
+ *   for fields the user hasn't seen yet. Use it when validation enforcement
+ *   on projection targets matters more than a clean initial form state.
+ *   The alternative is to declare these arrays as `required` + `minItems: 1`
+ *   + `default: [{}]` at the schema level, which avoids needing this helper.
+ *
+ * Properties:
+ *   - Idempotent: running twice yields the same result as running once.
+ *   - Non-destructive: existing values at target paths are preserved.
+ *   - Pure: returns a new object; does not mutate `data`.
+ *
+ * Example:
+ *   ```ts
+ *   const data = initFormDataFromSchema(schema);
+ *   const seeded = seedProjectionTargets(data, uischema);
+ *   // For uischema controls like
+ *   //   { type: 'Control', scope: '#/properties/data_rates',
+ *   //     options: { projection: '0.video_rate_usd' } }
+ *   // seeded.data_rates is now `[{}]` (was `undefined` or `[]`).
+ *   ```
+ */
+export function seedProjectionTargets(
+  data: unknown,
+  uischema: UISchemaLike | UISchemaLike[] | undefined,
+): unknown {
+  if (!uischema) return data;
+
+  const controls: { scope: string; projection: string }[] = [];
+  collectProjectionControls(uischema, controls);
+
+  let result = data;
+  for (const { scope, projection } of controls) {
+    const dataPath = scopeToDataPath(scope);
+    const segments = parseProjectionPath(projection);
+
+    // Seed only when a numeric segment is followed by a *string* segment —
+    // i.e., the consumer is reading a property of the array item, so the
+    // item must be an object. Numeric-at-end (`'0'`) addresses the array
+    // element itself, which can be any type (primitive, nested array,
+    // object) — we can't infer it from the uischema alone, so leave it
+    // alone. Numeric-followed-by-numeric (`'0.0'`) is a nested array; we'd
+    // need to seed `[]`, but again the inner item type is unknown.
+    for (let i = 0; i < segments.length; i++) {
+      if (typeof segments[i] !== "number") continue;
+      if (i + 1 >= segments.length) continue;
+      if (typeof segments[i + 1] !== "string") continue;
+
+      const partial = segments
+        .slice(0, i + 1)
+        .map((s) => String(s))
+        .join(".");
+      const fullPath = dataPath ? `${dataPath}.${partial}` : partial;
+
+      if (getProjectedValue(result, fullPath) === undefined) {
+        result = setProjectedValue(result, fullPath, {});
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Minimal UI schema shape this utility traverses. Compatible with
+ * `@jsonforms/core`'s `UISchemaElement` but kept local to avoid a runtime
+ * dep on `@jsonforms/core` (it's a peer dep — types only).
+ */
+export interface UISchemaLike {
+  type?: string;
+  scope?: string;
+  options?: { projection?: string; [key: string]: unknown };
+  elements?: UISchemaLike[];
+  [key: string]: unknown;
+}
+
+function collectProjectionControls(
+  ui: UISchemaLike | UISchemaLike[] | undefined,
+  out: { scope: string; projection: string }[],
+): void {
+  if (!ui) return;
+  if (Array.isArray(ui)) {
+    for (const el of ui) collectProjectionControls(el, out);
+    return;
+  }
+  if (typeof ui !== "object") return;
+
+  const projection = ui.options?.projection;
+  if (
+    ui.type === "Control" &&
+    typeof ui.scope === "string" &&
+    typeof projection === "string"
+  ) {
+    out.push({ scope: ui.scope, projection });
+  }
+
+  if (Array.isArray(ui.elements)) {
+    for (const el of ui.elements) collectProjectionControls(el, out);
+  }
+}
+
+/**
+ * Convert a JsonForms scope pointer (`#/properties/foo/properties/bar`) to
+ * a dot-separated data path (`foo.bar`). Drops `items` segments — array
+ * indices are added at runtime via the projection path, not the scope.
+ */
+function scopeToDataPath(scope: string): string {
+  if (!scope.startsWith("#/")) return "";
+  const parts = scope.slice(2).split("/");
+  const out: string[] = [];
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i] === "properties" && i + 1 < parts.length) {
+      out.push(parts[++i]!);
+    }
+  }
+  return out.join(".");
+}

package/src/core/transforms.ts

@@ -14,30 +14,38 @@ 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 interface FilterCondition {
+  key: string;
+  operator?: FilterOperator; // Defaults to "eq" when values is provided, "exists" behavior when neither
+  values?: unknown[];
+}
+
 export interface FilterTransform extends Transform {
   name: "filter";
-  key: string; // The key to check
-  values?: unknown[]; // Optional array of values to match against
+  key?: string; // Legacy: single key to check
+  values?: unknown[]; // Legacy: single values array
+  conditions?: FilterCondition[]; // Multi-condition filter (AND logic)
 }
 
 export type TransformStep = FlattenTransform | FilterTransform;
 
 export type TransformPipeline = TransformStep[];
 
-/**
- * Registry of transform functions
- */
 type TransformFunction = (items: unknown[], config: Transform) => unknown[];
 
 const transformRegistry: Record<string, TransformFunction> = {};
 
-/**
- * Register a transform function
- */
-export function registerTransform(name: string, fn: TransformFunction): void {
-  transformRegistry[name] = fn;
-}
-
 /**
  * Apply a pipeline of transforms to data
  */
@@ -124,29 +132,113 @@ function flattenTransform(items: unknown[], config: Transform): unknown[] {
   return flattened;
 }
 
+function isEmpty(value: unknown): boolean {
+  if (value === null || value === undefined) return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "string") return value.length === 0;
+  return false;
+}
+
+function evaluateCondition(
+  itemObj: Record<string, unknown>,
+  condition: FilterCondition,
+): boolean {
+  const value = itemObj[condition.key];
+  const operator = condition.operator ?? (condition.values ? "eq" : "eq");
+
+  switch (operator) {
+    case "eq":
+      if (!condition.values || condition.values.length === 0) {
+        return condition.key in itemObj;
+      }
+      return condition.values.includes(value);
+    case "neq":
+      if (!condition.values || condition.values.length === 0) {
+        return !(condition.key in itemObj);
+      }
+      return !condition.values.includes(value);
+    case "empty":
+      return isEmpty(value);
+    case "notEmpty":
+      return !isEmpty(value);
+    case "gt":
+      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)
+      );
+    case "lt":
+      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)
+      );
+    case "contains":
+      if (typeof value === "string" && condition.values) {
+        return condition.values.some((v) => value.includes(String(v)));
+      }
+      if (Array.isArray(value) && condition.values) {
+        return condition.values.some((v) => value.includes(v));
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+
 /**
- * Filter transform - filters items based on a key and optional values
+ * Filter transform - filters items based on conditions
+ *
+ * Supports legacy single key/values syntax and new multi-condition syntax.
+ * When using conditions, all conditions must match (AND logic).
+ *
+ * Operators:
+ *   eq       - item[key] matches one of values (default)
+ *   neq      - item[key] does NOT match any of values
+ *   empty    - item[key] is null, undefined, empty array, or empty string
+ *   notEmpty - inverse of empty
+ *   gt       - item[key] > values[0]
+ *   gte      - item[key] >= values[0]
+ *   lt       - item[key] < values[0]
+ *   lte      - item[key] <= values[0]
+ *   contains - string includes substring, or array includes value
  */
 function filterTransform(items: unknown[], config: Transform): unknown[] {
   const filterConfig = config as FilterTransform;
-  const { key, values } = filterConfig;
+
+  // Build conditions array from either new or legacy syntax
+  let conditions: FilterCondition[];
+
+  if (filterConfig.conditions) {
+    conditions = filterConfig.conditions;
+  } else if (filterConfig.key) {
+    // Legacy single key/values syntax
+    conditions = [{ key: filterConfig.key, values: filterConfig.values }];
+  } else {
+    return items;
+  }
 
   return items.filter((item) => {
     if (typeof item !== "object" || item === null) return false;
-
     const itemObj = item as Record<string, unknown>;
-
-    // If no values array provided, just check if the key exists
-    if (!values || values.length === 0) {
-      return key in itemObj;
-    }
-
-    // If values array provided, check if item[key] matches any of the values
-    const itemValue = itemObj[key];
-    return values.includes(itemValue);
+    return conditions.every((condition) =>
+      evaluateCondition(itemObj, condition),
+    );
   });
 }
 
 // Register built-in transforms
-registerTransform("flatten", flattenTransform);
-registerTransform("filter", filterTransform);
+transformRegistry["flatten"] = flattenTransform;
+transformRegistry["filter"] = filterTransform;

package/src/core/types.ts

@@ -44,3 +44,12 @@ export interface AuthConfig {
   token?: string | (() => string); // Generic token auth
   [key: string]: unknown; // Custom auth fields
 }
+
+export interface ConnectorDataLayer {
+  dataset_name?: string;
+  dataset_description?: string;
+  dataset_id?: number;
+  profile_id?: string;
+  profile_name?: string;
+  datasetWriteMode?: "append" | "overwrite";
+}

package/src/index.ts

@@ -3,19 +3,35 @@ 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");
-
 export { cache } from "./core/cache";
 export * from "./core/jsonpath";
 export { registry } from "./core/registry";
 export * from "./core/templating";
 export * from "./core/transforms";
+export * from "./core/projection";
+export * from "./core/resolveScope";
 // Core exports
 export * from "./core/types";
+export { initFormDataFromSchema } from "./core/initFormData";
+export { seedProjectionTargets } from "./core/seedProjectionTargets";
+export type { UISchemaLike } from "./core/seedProjectionTargets";
 
 // 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,
@@ -23,7 +39,10 @@ export {
   ProviderAutocomplete,
   ProviderSelect,
   ProviderMultiSelect,
+  ProviderObjectMultiSelect,
   useProvider,
+  createDataLayer,
+  useDataLayer,
   JfText,
   JfTextArea,
   JfNumber,
@@ -31,6 +50,7 @@ export {
   JfEnumArray,
   JfBoolean,
 } from "./vue";
+export type { DataLayer } from "./vue";
 
 export interface ProviderConfig {
   protocols?: Protocol[];