@auto-engineer/server-generator-nestjs 0.11.16

package/src/codegen/extract/projection.ts

@@ -0,0 +1,62 @@
+import type { Slice } from '@auto-engineer/narrative';
+
+interface ProjectionOrigin {
+  type: 'projection';
+  idField?: string;
+  name?: string;
+  singleton?: boolean;
+}
+
+interface HasOrigin {
+  origin: unknown;
+}
+
+function hasOrigin(dataSource: unknown): dataSource is HasOrigin {
+  return typeof dataSource === 'object' && dataSource !== null && 'origin' in dataSource;
+}
+
+function isProjectionOrigin(origin: unknown): origin is ProjectionOrigin {
+  if (typeof origin !== 'object' || origin === null) {
+    return false;
+  }
+
+  const obj = origin as Record<string, unknown>;
+  return obj.type === 'projection';
+}
+
+function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice, fieldName: K): string | undefined {
+  if (!('server' in slice)) return undefined;
+  const dataSource = slice.server?.data?.[0];
+  if (!hasOrigin(dataSource)) return undefined;
+
+  const origin = dataSource.origin;
+  if (isProjectionOrigin(origin)) {
+    const value = origin[fieldName];
+    if (typeof value === 'string') {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+export function extractProjectionIdField(slice: Slice): string | undefined {
+  return extractProjectionField(slice, 'idField');
+}
+
+export function extractProjectionName(slice: Slice): string | undefined {
+  return extractProjectionField(slice, 'name');
+}
+
+export function extractProjectionSingleton(slice: Slice): boolean {
+  if (!('server' in slice)) return false;
+  const dataSource = slice.server?.data?.[0];
+  if (!hasOrigin(dataSource)) return false;
+
+  const origin = dataSource.origin;
+  if (isProjectionOrigin(origin)) {
+    return origin.singleton === true;
+  }
+
+  return false;
+}

package/src/codegen/extract/query.ts

@@ -0,0 +1,28 @@
+import type { Slice } from '@auto-engineer/narrative';
+import { extractGwtSpecsFromSlice } from './step-converter';
+import type { EventExample, StateExample } from './step-types';
+
+interface QueryGwtCondition {
+  description: string;
+  given?: EventExample[];
+  when: EventExample[];
+  then: Array<{ stateRef: string; exampleData: Record<string, unknown> }>;
+}
+
+export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
+  if (slice.type !== 'query') return [];
+
+  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+
+  return gwtSpecs.map((gwt) => {
+    const givenEvents = Array.isArray(gwt.given) ? gwt.given.filter((i): i is EventExample => 'eventRef' in i) : [];
+    const whenEvents = Array.isArray(gwt.when) ? gwt.when.filter((i): i is EventExample => 'eventRef' in i) : [];
+
+    return {
+      description: gwt.description,
+      given: givenEvents.length > 0 ? givenEvents : undefined,
+      when: whenEvents,
+      then: gwt.then.filter((i): i is StateExample => 'stateRef' in i),
+    };
+  });
+}

package/src/codegen/extract/states.ts

@@ -0,0 +1,69 @@
+import type { Slice } from '@auto-engineer/narrative';
+import type { Message, MessageDefinition } from '../types';
+import { extractFieldsFromMessage } from './fields';
+
+interface DataItem {
+  origin?: unknown;
+  target?: {
+    name?: string;
+  };
+}
+
+function createStateMessage(stateName: string, allMessages: MessageDefinition[]): Message {
+  return {
+    type: stateName,
+    fields: extractFieldsFromMessage(stateName, 'state', allMessages),
+  };
+}
+
+function hasServerData(slice: Slice): slice is Slice & { server: { data: unknown[] } } {
+  return (
+    'server' in slice &&
+    Boolean(slice.server) &&
+    'data' in slice.server &&
+    Array.isArray(slice.server.data) &&
+    slice.server.data.length > 0
+  );
+}
+
+export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+  if (!hasServerData(slice)) {
+    return [];
+  }
+
+  const targets = slice.server.data
+    .map((d) => (d as DataItem).target?.name)
+    .filter((name): name is string => typeof name === 'string');
+  const uniqueTargets = Array.from(new Set(targets));
+
+  return uniqueTargets.map((name) => createStateMessage(name, allMessages));
+}
+
+export function extractStatesFromData(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+  if (!hasServerData(slice)) {
+    return [];
+  }
+
+  const states: Message[] = [];
+  const seenStates = new Set<string>();
+
+  for (const dataItem of slice.server.data) {
+    const item = dataItem as DataItem;
+    if (!('origin' in item) || typeof item.target?.name !== 'string') {
+      continue;
+    }
+
+    const stateName = item.target.name;
+    if (seenStates.has(stateName)) {
+      continue;
+    }
+
+    const fields = extractFieldsFromMessage(stateName, 'state', allMessages);
+    if (fields.length > 0) {
+      states.push(createStateMessage(stateName, allMessages));
+      seenStates.add(stateName);
+    }
+  }
+
+  return states;
+}

package/src/codegen/extract/step-converter.ts

@@ -0,0 +1,124 @@
+import type { Example, Slice, Spec } from '@auto-engineer/narrative';
+import {
+  type CommandExample,
+  type ErrorRef,
+  type EventExample,
+  getSliceType,
+  isStepWithDocString,
+  isStepWithError,
+  type MajorKeyword,
+  resolveMajorKeyword,
+  type SliceType,
+  type StateExample,
+} from './step-types';
+
+export type { CommandExample, ErrorRef, EventExample, SliceType, StateExample };
+export { getSliceType };
+
+export interface GwtResult {
+  given: EventExample[];
+  when: CommandExample | EventExample[];
+  then: Array<EventExample | StateExample | CommandExample | ErrorRef>;
+  description: string;
+}
+
+interface ParsedSteps {
+  given: EventExample[];
+  whenItems: Array<{ text: string; exampleData: Record<string, unknown> }>;
+  thenItems: Array<{ text: string; exampleData: Record<string, unknown> }>;
+  thenErrors: ErrorRef[];
+}
+
+function parseSteps(example: Example): ParsedSteps {
+  const given: EventExample[] = [];
+  const whenItems: Array<{ text: string; exampleData: Record<string, unknown> }> = [];
+  const thenItems: Array<{ text: string; exampleData: Record<string, unknown> }> = [];
+  const thenErrors: ErrorRef[] = [];
+
+  let effectiveKeyword: MajorKeyword = 'Given';
+
+  for (const step of example.steps) {
+    if (isStepWithError(step)) {
+      thenErrors.push({ errorType: step.error.type, message: step.error.message });
+      continue;
+    }
+
+    if (!isStepWithDocString(step)) continue;
+
+    effectiveKeyword = resolveMajorKeyword(step.keyword, effectiveKeyword);
+    const exampleData = step.docString ?? {};
+
+    if (effectiveKeyword === 'Given') {
+      given.push({ eventRef: step.text, exampleData });
+    } else if (effectiveKeyword === 'When') {
+      whenItems.push({ text: step.text, exampleData });
+    } else if (effectiveKeyword === 'Then') {
+      thenItems.push({ text: step.text, exampleData });
+    }
+  }
+
+  return { given, whenItems, thenItems, thenErrors };
+}
+
+function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description: string): GwtResult {
+  const { given, whenItems, thenItems, thenErrors } = parsed;
+
+  if (sliceType === 'command') {
+    return {
+      given,
+      when: { commandRef: whenItems[0]?.text ?? '', exampleData: whenItems[0]?.exampleData ?? {} },
+      then: [...thenItems.map((t) => ({ eventRef: t.text, exampleData: t.exampleData })), ...thenErrors],
+      description,
+    };
+  }
+
+  if (sliceType === 'react') {
+    return {
+      given,
+      when: whenItems.map((w) => ({ eventRef: w.text, exampleData: w.exampleData })),
+      then: [...thenItems.map((t) => ({ commandRef: t.text, exampleData: t.exampleData })), ...thenErrors],
+      description,
+    };
+  }
+
+  return {
+    given,
+    when: whenItems.map((w) => ({ eventRef: w.text, exampleData: w.exampleData })),
+    then: [...thenItems.map((t) => ({ stateRef: t.text, exampleData: t.exampleData })), ...thenErrors],
+    description,
+  };
+}
+
+export function stepsToGwt(example: Example, sliceType: SliceType): GwtResult {
+  const parsed = parseSteps(example);
+  return buildGwtResult(sliceType, parsed, example.name);
+}
+
+export interface GwtConditionWithRule extends GwtResult {
+  ruleDescription: string;
+}
+
+export function extractGwtFromSpecs(specs: Spec[], sliceType: SliceType): GwtConditionWithRule[] {
+  const results: GwtConditionWithRule[] = [];
+
+  for (const spec of specs) {
+    for (const rule of spec.rules) {
+      for (const example of rule.examples) {
+        const gwt = stepsToGwt(example, sliceType);
+        results.push({
+          ...gwt,
+          ruleDescription: rule.name,
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+export function extractGwtSpecsFromSlice(slice: Slice): GwtConditionWithRule[] {
+  if (!('server' in slice)) return [];
+  const specs = slice.server?.specs;
+  if (!Array.isArray(specs) || specs.length === 0) return [];
+  return extractGwtFromSpecs(specs, getSliceType(slice));
+}

package/src/codegen/extract/step-types.ts

@@ -0,0 +1,51 @@
+import type { Slice, Step, StepWithDocStringSchema, StepWithErrorSchema } from '@auto-engineer/narrative';
+import type { z } from 'zod';
+
+export type StepWithDocString = z.infer<typeof StepWithDocStringSchema>;
+export type StepWithError = z.infer<typeof StepWithErrorSchema>;
+
+export type StepKeyword = StepWithDocString['keyword'];
+export type MajorKeyword = Exclude<StepKeyword, 'And'>;
+
+export type ErrorType = StepWithError['error']['type'];
+
+export type SliceType = Extract<Slice['type'], 'command' | 'query' | 'react'>;
+
+export function getSliceType(slice: Slice): SliceType {
+  if (slice.type === 'command' || slice.type === 'query' || slice.type === 'react') {
+    return slice.type;
+  }
+  return 'command';
+}
+
+export function isStepWithDocString(step: Step): step is StepWithDocString {
+  return 'text' in step;
+}
+
+export function isStepWithError(step: Step): step is StepWithError {
+  return 'error' in step;
+}
+
+export function resolveMajorKeyword(keyword: StepKeyword, current: MajorKeyword): MajorKeyword {
+  return keyword === 'And' ? current : keyword;
+}
+
+export interface CommandExample {
+  commandRef: string;
+  exampleData: Record<string, unknown>;
+}
+
+export interface EventExample {
+  eventRef: string;
+  exampleData: Record<string, unknown>;
+}
+
+export interface StateExample {
+  stateRef: string;
+  exampleData: Record<string, unknown>;
+}
+
+export interface ErrorRef {
+  errorType: ErrorType;
+  message?: string;
+}

package/src/codegen/extract/type-helpers.ts

@@ -0,0 +1,102 @@
+export function isInlineObject(ts: string): boolean {
+  return /^\{[\s\S]*\}$/.test((ts ?? '').trim());
+}
+
+export function isInlineObjectArray(ts: string): boolean {
+  const t = (ts ?? '').trim();
+  return /^Array<\{[\s\S]*\}>$/.test(t) || /^\{[\s\S]*\}\[\]$/.test(t);
+}
+
+export function baseTs(ts: string): string {
+  return (ts ?? 'string').replace(/\s*\|\s*null\b/g, '').trim();
+}
+
+export function createIsEnumType(toTsFieldType: (ts: string) => string) {
+  return (tsType: string): boolean => {
+    const converted = toTsFieldType(tsType);
+    const base = converted
+      .replace(/\s*\|\s*null\b/g, '')
+      .replace(/\[\]$/, '')
+      .trim();
+    return (
+      /^[A-Z][a-zA-Z0-9]*$/.test(base) &&
+      ![
+        'String',
+        'Number',
+        'Boolean',
+        'Date',
+        'ID',
+        'Int',
+        'Float',
+        'GraphQLISODateTime',
+        'GraphQLJSON',
+        'JSON',
+      ].includes(base)
+    );
+  };
+}
+
+export function createFieldUsesDate(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLISODateTime')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*Date\b/.test(b);
+    return false;
+  };
+}
+
+export function createFieldUsesJSON(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('GraphQLJSON') || gqlType.includes('JSON')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) return /:\s*(unknown|any|object)\b/.test(b);
+    return false;
+  };
+}
+
+export function createFieldUsesFloat(graphqlType: (ts: string) => string) {
+  return (ts: string): boolean => {
+    const b = baseTs(ts);
+    const gqlType = graphqlType(b);
+    if (gqlType.includes('Float')) return true;
+    if (isInlineObject(b) || isInlineObjectArray(b)) {
+      const inner = b.trim().startsWith('Array<')
+        ? b
+            .trim()
+            .replace(/^Array<\{/, '{')
+            .replace(/}>$/, '}')
+        : b.trim().replace(/\[\]$/, '');
+      const match = inner.match(/^\{([\s\S]*)\}$/);
+      const body = match ? match[1] : '';
+      const rawFields = body.split(/[,;]\s*/).filter(Boolean);
+      return rawFields.some((f) => {
+        const parts = f.split(':');
+        const type = parts.slice(1).join(':').trim();
+        return type.length > 0 && graphqlType(type).includes('Float');
+      });
+    }
+    return false;
+  };
+}
+
+export function extractEnumName(tsType: string, toTsFieldType: (ts: string) => string): string {
+  return toTsFieldType(tsType)
+    .replace(/\s*\|\s*null\b/g, '')
+    .replace(/\[\]$/, '')
+    .trim();
+}
+
+export function createCollectEnumNames(isEnumType: (tsType: string) => boolean, toTsFieldType: (ts: string) => string) {
+  return (fields: Array<{ type?: string; tsType?: string }>): string[] => {
+    const enumNames = new Set<string>();
+    for (const field of fields) {
+      const fieldType = field.type ?? field.tsType;
+      if (fieldType !== undefined && fieldType !== null && fieldType.length > 0 && isEnumType(fieldType)) {
+        enumNames.add(extractEnumName(fieldType, toTsFieldType));
+      }
+    }
+    return Array.from(enumNames).sort();
+  };
+}