@freelygive/canvas-jsonapi 0.0.0

package/src/validate.js

@@ -0,0 +1,298 @@
+/* global process */
+/**
+ * Component input validation module.
+ *
+ * Validates component inputs against their component.yml definitions
+ * to catch errors before sending to the server (which returns generic 503).
+ *
+ * Reads componentDir from canvas.config.json in the current working directory,
+ * falls back to CANVAS_COMPONENT_DIR env var, then ./src/components.
+ */
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import yaml from 'js-yaml';
+
+function getComponentsDir() {
+  // Prefer canvas.config.json
+  const configPath = resolve(process.cwd(), 'canvas.config.json');
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (config.componentDir) {
+        return resolve(process.cwd(), config.componentDir);
+      }
+    } catch {
+      // Fall through to env var / default
+    }
+  }
+
+  // Fall back to env var
+  const envDir = process.env.CANVAS_COMPONENT_DIR;
+  if (envDir) {
+    return resolve(envDir);
+  }
+
+  return resolve(process.cwd(), 'src/components');
+}
+
+// Cache for loaded component definitions
+const componentCache = new Map();
+
+/**
+ * Load and cache a component definition from its component.yml file.
+ * @param {string} machineName - The component machine name (without js. prefix)
+ * @returns {object|null} The parsed component definition or null if not found
+ */
+export function loadComponentDefinition(machineName) {
+  if (componentCache.has(machineName)) {
+    return componentCache.get(machineName);
+  }
+
+  const componentsDir = getComponentsDir();
+  const componentPath = join(componentsDir, machineName, 'component.yml');
+
+  if (!existsSync(componentPath)) {
+    componentCache.set(machineName, null);
+    return null;
+  }
+
+  try {
+    const content = readFileSync(componentPath, 'utf-8');
+    const definition = yaml.load(content);
+    componentCache.set(machineName, definition);
+    return definition;
+  } catch (error) {
+    console.error(`Error parsing ${componentPath}: ${error.message}`);
+    componentCache.set(machineName, null);
+    return null;
+  }
+}
+
+/**
+ * Extract the machine name from a component_id.
+ * @param {string} componentId - The component ID (e.g., "js.button")
+ * @returns {string} The machine name (e.g., "button")
+ */
+export function getMachineNameFromId(componentId) {
+  if (componentId.startsWith('js.')) {
+    return componentId.slice(3);
+  }
+  return componentId;
+}
+
+/**
+ * Validate a single prop value against its schema.
+ * @param {string} propName - The name of the prop
+ * @param {*} value - The value to validate
+ * @param {object} schema - The prop schema from component.yml
+ * @returns {string[]} Array of error messages (empty if valid)
+ */
+function validateProp(propName, value, schema) {
+  const errors = [];
+
+  if (value === undefined || value === null) {
+    return errors; // Let required check handle missing values
+  }
+
+  // Type validation
+  if (schema.type) {
+    const actualType = Array.isArray(value) ? 'array' : typeof value;
+
+    // Handle object type for complex inputs like image
+    if (schema.type === 'object') {
+      if (actualType !== 'object' || Array.isArray(value)) {
+        errors.push(`${propName}: expected object, got ${actualType}`);
+      }
+    } else if (schema.type === 'string') {
+      // Accept multiple valid string representations:
+      // - Plain strings
+      // - Objects with 'value' property (for HTML content from Drupal)
+      // - Objects with 'uri' property (for links from Drupal Canvas)
+      const isPlainString = actualType === 'string';
+      const isHtmlObject = actualType === 'object' && 'value' in value;
+      const isLinkObject =
+        actualType === 'object' &&
+        'uri' in value &&
+        (schema.format === 'uri' || schema.format === 'uri-reference');
+
+      if (!isPlainString && !isHtmlObject && !isLinkObject) {
+        errors.push(`${propName}: expected string, got ${actualType}`);
+      }
+    } else if (schema.type === 'boolean') {
+      if (actualType !== 'boolean') {
+        errors.push(`${propName}: expected boolean, got ${actualType}`);
+      }
+    } else if (schema.type === 'number' || schema.type === 'integer') {
+      if (actualType !== 'number') {
+        errors.push(`${propName}: expected number, got ${actualType}`);
+      }
+    } else if (schema.type === 'array') {
+      if (!Array.isArray(value)) {
+        errors.push(`${propName}: expected array, got ${actualType}`);
+      }
+    }
+  }
+
+  // Enum validation
+  if (schema.enum && Array.isArray(schema.enum)) {
+    // Get the actual string value (handle objects with value property)
+    const checkValue =
+      typeof value === 'object' && 'value' in value ? value.value : value;
+
+    // Only validate strings against enum
+    if (typeof checkValue === 'string' && !schema.enum.includes(checkValue)) {
+      errors.push(
+        `${propName}: "${checkValue}" is not a valid option. ` +
+          `Valid options: ${schema.enum.join(', ')}`,
+      );
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Validate a component's inputs against its definition.
+ * @param {string} componentId - The component ID (e.g., "js.button")
+ * @param {object} inputs - The input values to validate
+ * @returns {{valid: boolean, errors: string[]}} Validation result
+ */
+export function validateComponentInputs(componentId, inputs) {
+  const machineName = getMachineNameFromId(componentId);
+  const definition = loadComponentDefinition(machineName);
+  const errors = [];
+
+  if (!definition) {
+    // Component not found - skip validation (might be external)
+    return {
+      valid: true,
+      errors: [],
+      warning: `Unknown component: ${componentId}`,
+    };
+  }
+
+  const props = definition.props?.properties || {};
+  const required = definition.required || [];
+
+  // Check required props
+  for (const propName of required) {
+    if (inputs[propName] === undefined || inputs[propName] === null) {
+      errors.push(`${propName}: required prop is missing`);
+    }
+  }
+
+  // Validate each provided input
+  for (const [propName, value] of Object.entries(inputs || {})) {
+    const schema = props[propName];
+
+    if (!schema) {
+      // Unknown prop - warn but don't fail
+      errors.push(`${propName}: unknown prop for ${componentId}`);
+      continue;
+    }
+
+    const propErrors = validateProp(propName, value, schema);
+    errors.push(...propErrors);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate all components in a content entity.
+ * @param {object} data - The content data (with data.attributes.components or attributes.components)
+ * @returns {{valid: boolean, errors: Array<{component: string, uuid: string, errors: string[]}>}}
+ */
+export function validateContentComponents(data) {
+  const attributes = data.data?.attributes || data.attributes || {};
+  const components = attributes.components;
+
+  if (!Array.isArray(components)) {
+    return { valid: true, errors: [] };
+  }
+
+  const allErrors = [];
+  const warnings = [];
+
+  for (const component of components) {
+    const componentId = component.component_id;
+    const uuid = component.uuid || '(no uuid)';
+
+    // Parse inputs if they're a JSON string
+    let inputs = component.inputs;
+    if (typeof inputs === 'string') {
+      try {
+        inputs = JSON.parse(inputs);
+      } catch {
+        allErrors.push({
+          component: componentId,
+          uuid,
+          errors: ['inputs: invalid JSON string'],
+        });
+        continue;
+      }
+    }
+
+    const result = validateComponentInputs(componentId, inputs);
+
+    if (result.warning) {
+      warnings.push(result.warning);
+    }
+
+    if (!result.valid) {
+      allErrors.push({
+        component: componentId,
+        uuid,
+        errors: result.errors,
+      });
+    }
+  }
+
+  return {
+    valid: allErrors.length === 0,
+    errors: allErrors,
+    warnings,
+  };
+}
+
+/**
+ * Format validation errors for display.
+ * @param {Array<{component: string, uuid: string, errors: string[]}>} errors
+ * @returns {string} Formatted error message
+ */
+export function formatValidationErrors(errors) {
+  const lines = ['Component validation failed:'];
+
+  for (const { component, uuid, errors: componentErrors } of errors) {
+    lines.push(`\n  ${component} (${uuid}):`);
+    for (const error of componentErrors) {
+      lines.push(`    - ${error}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * List all available components.
+ * @returns {string[]} Array of component machine names
+ */
+export function listAvailableComponents() {
+  const componentsDir = getComponentsDir();
+
+  if (!existsSync(componentsDir)) {
+    return [];
+  }
+
+  const entries = readdirSync(componentsDir, { withFileTypes: true });
+
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .filter((entry) =>
+      existsSync(join(componentsDir, entry.name, 'component.yml')),
+    )
+    .map((entry) => entry.name);
+}

package/src/whoami.js

@@ -0,0 +1,34 @@
+/* global process */
+/**
+ * Shows current OAuth authentication status.
+ */
+import { authenticatedFetch, getSiteUrl } from './client.js';
+
+export async function whoami() {
+  try {
+    const url = `${getSiteUrl()}/oauth/userinfo`;
+    const response = await authenticatedFetch(url);
+    const contentType = response.headers.get('content-type') || '';
+
+    // Handle non-JSON responses
+    if (!contentType.includes('application/json')) {
+      const text = await response.text();
+      console.error(`HTTP ${response.status}: ${response.statusText}`);
+      console.error(text.slice(0, 500));
+      process.exit(1);
+    }
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      console.error(`HTTP ${response.status}: ${response.statusText}`);
+      console.error(JSON.stringify(result, null, 2));
+      process.exit(1);
+    }
+
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}