@auto-engineer/narrative 1.88.0 → 1.90.0

package/ketchup-plan.md

@@ -0,0 +1,13 @@
+# Ketchup Plan: Validate Slice Requests Against Model Messages
+
+## TODO
+
+(none)
+
+## DONE
+
+- [x] Burst 1: Skeleton + parse safety + export convertJsonAstToSdl (4b1d0b12)
+- [x] Burst 2: Mutation validation (wrong op type, missing input, type mismatch, message not found) (4059d393)
+- [x] Burst 3: Query — operation type + state + top-level fields (73c8c99c)
+- [x] Burst 4: Query — nested field validation (inline objects, referenced messages, unresolvable) (39d3d083)
+- [x] Burst 5: Export from index.ts + integration test (885a805f)

package/package.json

@@ -27,9 +27,9 @@
     "typescript": "^5.9.2",
     "zod": "^3.22.4",
     "zod-to-json-schema": "^3.22.3",
-    "@auto-engineer/file-store": "1.88.0",
-    "@auto-engineer/id": "1.88.0",
-    "@auto-engineer/message-bus": "1.88.0"
+    "@auto-engineer/file-store": "1.90.0",
+    "@auto-engineer/id": "1.90.0",
+    "@auto-engineer/message-bus": "1.90.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -39,7 +39,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.88.0",
+  "version": "1.90.0",
   "scripts": {
     "build": "tsx scripts/build.ts",
     "test": "vitest run --reporter=dot",

package/src/index.ts

@@ -53,9 +53,12 @@ export {
   specs,
   thenError,
 } from './narrative';
+export type { ParsedArg, ParsedGraphQlOperation } from './parse-graphql-request';
+export { parseGraphQlRequest, parseSliceRequest } from './parse-graphql-request';
 export * from './schema';
 export { createNarrativeSpec, given as testGiven, when as testWhen } from './testing';
 export type { GeneratedNarratives } from './transformers/model-to-narrative';
 export { modelToNarrative } from './transformers/model-to-narrative';
-
 export { detectQueryAction, extractQueryNameFromRequest } from './transformers/narrative-to-model/spec-processors';
+export type { SliceRequestValidationError } from './validate-slice-requests';
+export { validateSliceRequests } from './validate-slice-requests';

package/src/parse-graphql-request.specs.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { parseGraphQlRequest, parseSliceRequest } from './parse-graphql-request';
+
+describe('parseGraphQlRequest', () => {
+  it('parses a query operation', () => {
+    const request = `query GetUsers($status: String) {
+      users(status: $status) {
+        id
+        name
+      }
+    }`;
+
+    expect(parseGraphQlRequest(request)).toEqual({
+      operationName: 'users',
+      args: [{ name: 'status', tsType: 'string', graphqlType: 'String', nullable: true }],
+    });
+  });
+
+  it('parses a mutation operation', () => {
+    const request = `mutation SubmitAnswer($input: SubmitAnswerInput!) {
+      submitQuestionnaireAnswer(input: $input) {
+        success
+      }
+    }`;
+
+    expect(parseGraphQlRequest(request)).toEqual({
+      operationName: 'submitQuestionnaireAnswer',
+      args: [{ name: 'input', tsType: 'SubmitAnswerInput', graphqlType: 'SubmitAnswerInput', nullable: false }],
+    });
+  });
+});
+
+describe('parseSliceRequest', () => {
+  it('returns parsed operation when request is present', () => {
+    const slice = {
+      request: `query GetItems { items { id } }`,
+    };
+
+    expect(parseSliceRequest(slice)).toEqual({
+      operationName: 'items',
+      args: [],
+    });
+  });
+
+  it('returns undefined when request is absent', () => {
+    expect(parseSliceRequest({})).toEqual(undefined);
+  });
+
+  it('returns undefined when request is undefined', () => {
+    expect(parseSliceRequest({ request: undefined })).toEqual(undefined);
+  });
+});

package/src/parse-graphql-request.ts

@@ -0,0 +1,99 @@
+import { type OperationDefinitionNode, parse, print, type TypeNode } from 'graphql';
+
+export interface ParsedArg {
+  name: string;
+  tsType: string;
+  graphqlType: string;
+  nullable: boolean;
+}
+
+export interface ParsedGraphQlOperation {
+  operationName: string;
+  args: ParsedArg[];
+}
+
+function getTypeName(typeNode: TypeNode): { graphqlType: string; nullable: boolean } {
+  if (typeNode.kind === 'NamedType') {
+    return { graphqlType: typeNode.name.value, nullable: true };
+  } else if (typeNode.kind === 'NonNullType') {
+    const inner = getTypeName(typeNode.type);
+    return { ...inner, nullable: false };
+  } else {
+    return getTypeName(typeNode.type);
+  }
+}
+
+function graphqlToTs(type: string): string {
+  switch (type) {
+    case 'String':
+      return 'string';
+    case 'Int':
+    case 'Float':
+    case 'Number':
+      return 'number';
+    case 'Boolean':
+      return 'boolean';
+    case 'Date':
+      return 'Date';
+    default:
+      return type;
+  }
+}
+
+export function convertJsonAstToSdl(request: string): string {
+  if (request.startsWith('{') && request.includes('"kind"')) {
+    try {
+      const ast = JSON.parse(request) as unknown;
+      if (typeof ast === 'object' && ast !== null && 'kind' in ast && ast.kind === 'Document') {
+        return print(ast as Parameters<typeof print>[0]);
+      }
+    } catch {
+      // If parsing fails, assume it's already a GraphQL string
+    }
+  }
+  return request;
+}
+
+export function parseGraphQlRequest(request: string): ParsedGraphQlOperation {
+  const sdlRequest = convertJsonAstToSdl(request);
+
+  const ast = parse(sdlRequest);
+  const op = ast.definitions.find(
+    (d): d is OperationDefinitionNode =>
+      d.kind === 'OperationDefinition' && (d.operation === 'query' || d.operation === 'mutation'),
+  );
+
+  if (!op) throw new Error('No query or mutation operation found');
+
+  const operationName = op.name?.value;
+  if (operationName == null) throw new Error('Operation must have a name');
+
+  const args: ParsedArg[] = (op.variableDefinitions ?? []).map((def) => {
+    const varName = def.variable.name.value;
+    const { graphqlType, nullable } = getTypeName(def.type);
+    return {
+      name: varName,
+      graphqlType,
+      tsType: graphqlToTs(graphqlType),
+      nullable,
+    };
+  });
+
+  const field = op.selectionSet.selections[0];
+  if (field?.kind !== 'Field' || !field.name.value) {
+    throw new Error('Selection must be a field');
+  }
+
+  return {
+    operationName: field.name.value,
+    args,
+  };
+}
+
+export function parseSliceRequest(slice: {
+  request?: string;
+  [key: string]: unknown;
+}): ParsedGraphQlOperation | undefined {
+  if (slice.request == null) return undefined;
+  return parseGraphQlRequest(slice.request);
+}