@auto-engineer/narrative 1.88.0 → 1.90.0

package/src/validate-slice-requests.ts

@@ -0,0 +1,298 @@
+import { type DocumentNode, type OperationDefinitionNode, parse, type SelectionSetNode, type TypeNode } from 'graphql';
+import { convertJsonAstToSdl } from './parse-graphql-request';
+import type { CommandSlice, Model, QuerySlice } from './schema';
+
+export interface SliceRequestValidationError {
+  type:
+    | 'request_parse_error'
+    | 'mutation_wrong_operation_type'
+    | 'mutation_missing_input_arg'
+    | 'mutation_input_type_mismatch'
+    | 'mutation_message_not_found'
+    | 'query_wrong_operation_type'
+    | 'query_state_not_found'
+    | 'query_field_not_found'
+    | 'query_nested_field_not_found';
+  message: string;
+  flowName: string;
+  sliceName: string;
+}
+
+type ParseResult = { ok: true; operation: OperationDefinitionNode } | { ok: false; error: string };
+
+function parseRequestSafe(request: string): ParseResult {
+  const sdl = convertJsonAstToSdl(request);
+
+  let ast: DocumentNode;
+  try {
+    ast = parse(sdl);
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+
+  const op = ast.definitions.find((d): d is OperationDefinitionNode => d.kind === 'OperationDefinition');
+
+  if (!op) {
+    return { ok: false, error: 'No operation found in request' };
+  }
+
+  if (!op.name) {
+    return { ok: false, error: 'Operation must have a name' };
+  }
+
+  return { ok: true, operation: op };
+}
+
+function validateSlice(
+  slice: CommandSlice | QuerySlice,
+  model: Model,
+  flowName: string,
+): SliceRequestValidationError[] {
+  if (!slice.request || slice.request.trim() === '') return [];
+
+  const sliceName = slice.name;
+  const parsed = parseRequestSafe(slice.request);
+
+  if (!parsed.ok) {
+    return [{ type: 'request_parse_error', message: parsed.error, flowName, sliceName }];
+  }
+
+  if (slice.type === 'command') {
+    return validateMutationRequest(parsed.operation, model, flowName, sliceName);
+  }
+  return validateQueryRequest(parsed.operation, model, slice, flowName, sliceName);
+}
+
+export function validateSliceRequests(model: Model): SliceRequestValidationError[] {
+  const errors: SliceRequestValidationError[] = [];
+
+  for (const narrative of model.narratives) {
+    for (const slice of narrative.slices) {
+      if (slice.type !== 'command' && slice.type !== 'query') continue;
+      errors.push(...validateSlice(slice, model, narrative.name));
+    }
+  }
+
+  return errors;
+}
+
+function unwrapType(typeNode: TypeNode): string {
+  if (typeNode.kind === 'NamedType') return typeNode.name.value;
+  return unwrapType(typeNode.type);
+}
+
+function validateMutationRequest(
+  operation: OperationDefinitionNode,
+  model: Model,
+  flowName: string,
+  sliceName: string,
+): SliceRequestValidationError[] {
+  const errors: SliceRequestValidationError[] = [];
+  const operationName = operation.name!.value;
+
+  if (operation.operation !== 'mutation') {
+    errors.push({
+      type: 'mutation_wrong_operation_type',
+      message: `Command slice '${sliceName}' request should be a mutation, but found ${operation.operation}`,
+      flowName,
+      sliceName,
+    });
+    return errors;
+  }
+
+  const inputVar = (operation.variableDefinitions ?? []).find((v) => v.variable.name.value === 'input');
+
+  if (!inputVar) {
+    errors.push({
+      type: 'mutation_missing_input_arg',
+      message: `Mutation '${operationName}' is missing required $input variable`,
+      flowName,
+      sliceName,
+    });
+    return errors;
+  }
+
+  const inputTypeName = unwrapType(inputVar.type);
+  const expectedTypeName = `${operationName}Input`;
+
+  if (inputTypeName !== expectedTypeName) {
+    errors.push({
+      type: 'mutation_input_type_mismatch',
+      message: `Mutation '${operationName}' input type should be '${expectedTypeName}', but found '${inputTypeName}'`,
+      flowName,
+      sliceName,
+    });
+    return errors;
+  }
+
+  const commandExists = model.messages.some((m) => m.type === 'command' && m.name === operationName);
+
+  if (!commandExists) {
+    errors.push({
+      type: 'mutation_message_not_found',
+      message: `No command message '${operationName}' found in model.messages`,
+      flowName,
+      sliceName,
+    });
+  }
+
+  return errors;
+}
+
+function isInlineObject(ts: string): boolean {
+  return /^\{[\s\S]*\}$/.test(ts.trim());
+}
+
+function isInlineObjectArray(ts: string): boolean {
+  const t = ts.trim();
+  return /^Array<\{[\s\S]*\}>$/.test(t) || /^\{[\s\S]*\}\[\]$/.test(t);
+}
+
+function extractObjectBody(tsType: string): string | null {
+  const t = tsType.trim();
+  let inner: string;
+  if (t.startsWith('Array<{') && t.endsWith('}>')) {
+    inner = t.slice(6, -1);
+  } else if (t.endsWith('[]')) {
+    inner = t.slice(0, -2).trim();
+  } else {
+    inner = t;
+  }
+  const match = inner.match(/^\{([\s\S]*)\}$/);
+  return match ? match[1] : null;
+}
+
+function splitFieldsRespectingNesting(body: string): string[] {
+  const fields: string[] = [];
+  let current = '';
+  let depth = 0;
+  for (const char of body) {
+    if (char === '<' || char === '{') depth++;
+    if (char === '>' || char === '}') depth--;
+    if ((char === ';' || char === ',') && depth === 0) {
+      const trimmed = current.trim();
+      if (trimmed) fields.push(trimmed);
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+  const trimmed = current.trim();
+  if (trimmed) fields.push(trimmed);
+  return fields;
+}
+
+function extractInlineFieldNames(tsType: string): string[] {
+  const body = extractObjectBody(tsType);
+  if (body === null) return [];
+  return splitFieldsRespectingNesting(body)
+    .map((part) => part.split(':')[0].trim())
+    .filter((name) => name.length > 0);
+}
+
+function resolveNestedFieldNames(fieldType: string, model: Model): string[] | null {
+  const trimmed = fieldType.trim();
+  if (isInlineObject(trimmed) || isInlineObjectArray(trimmed)) {
+    return extractInlineFieldNames(trimmed);
+  }
+  const referencedMessage = model.messages.find((m) => m.name === trimmed);
+  if (referencedMessage) {
+    return referencedMessage.fields.map((f) => f.name);
+  }
+  return null;
+}
+
+interface SelectionField {
+  name: string;
+  children?: SelectionField[];
+}
+
+function extractSelections(selectionSet: SelectionSetNode): SelectionField[] {
+  const fields: SelectionField[] = [];
+  for (const sel of selectionSet.selections) {
+    if (sel.kind !== 'Field') continue;
+    if (sel.name.value === '__typename') continue;
+    const field: SelectionField = { name: sel.name.value };
+    if (sel.selectionSet) {
+      field.children = extractSelections(sel.selectionSet);
+    }
+    fields.push(field);
+  }
+  return fields;
+}
+
+function validateQueryRequest(
+  operation: OperationDefinitionNode,
+  model: Model,
+  slice: QuerySlice,
+  flowName: string,
+  sliceName: string,
+): SliceRequestValidationError[] {
+  const errors: SliceRequestValidationError[] = [];
+  const operationName = operation.name!.value;
+
+  if (operation.operation !== 'query') {
+    errors.push({
+      type: 'query_wrong_operation_type',
+      message: `Query slice '${sliceName}' request should be a query, but found ${operation.operation}`,
+      flowName,
+      sliceName,
+    });
+    return errors;
+  }
+
+  const targetName = slice.server?.data?.items?.[0]?.target?.name;
+  if (!targetName) return errors;
+
+  const stateMessage = model.messages.find((m) => m.type === 'state' && m.name === targetName);
+
+  if (!stateMessage) {
+    errors.push({
+      type: 'query_state_not_found',
+      message: `State '${targetName}' referenced by query '${operationName}' not found in model.messages`,
+      flowName,
+      sliceName,
+    });
+    return errors;
+  }
+
+  const rootSelection = operation.selectionSet.selections[0];
+  if (!rootSelection || rootSelection.kind !== 'Field' || !rootSelection.selectionSet) return errors;
+
+  const selectedFields = extractSelections(rootSelection.selectionSet);
+  const stateFieldNames = new Set(stateMessage.fields.map((f) => f.name));
+
+  for (const sel of selectedFields) {
+    if (!stateFieldNames.has(sel.name)) {
+      errors.push({
+        type: 'query_field_not_found',
+        message: `Field '${sel.name}' in query '${operationName}' not found on state '${targetName}'`,
+        flowName,
+        sliceName,
+      });
+      continue;
+    }
+
+    if (sel.children && sel.children.length > 0) {
+      const stateField = stateMessage.fields.find((f) => f.name === sel.name);
+      if (!stateField) continue;
+
+      const nestedNames = resolveNestedFieldNames(stateField.type, model);
+      if (nestedNames === null) continue;
+
+      const nestedNameSet = new Set(nestedNames);
+      for (const child of sel.children) {
+        if (!nestedNameSet.has(child.name)) {
+          errors.push({
+            type: 'query_nested_field_not_found',
+            message: `Nested field '${child.name}' in query '${operationName}' not found on type of '${sel.name}'`,
+            flowName,
+            sliceName,
+          });
+        }
+      }
+    }
+  }
+
+  return errors;
+}