@cratis/screenplay-language 0.1.0

package/sub-languages/projection/Validator.ts

@@ -0,0 +1,387 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { editor } from 'monaco-editor';
+import type { JsonSchema, ReadModelInfo, DraftReadModelInfo } from './index';
+
+export class Validator {
+    private readModels: ReadModelInfo[] = [];
+    private eventSchemas: Record<string, JsonSchema> = {};
+    private draftReadModel: DraftReadModelInfo | null = null;
+
+    setReadModels(readModels: ReadModelInfo[]): void {
+        this.readModels = readModels || [];
+    }
+
+    setDraftReadModel(draft: DraftReadModelInfo | null): void {
+        this.draftReadModel = draft;
+    }
+
+    // Keep for backwards compatibility
+    setReadModelSchemas(schemas: JsonSchema[]): void {
+        this.readModels = schemas.map(schema => ({
+            identifier: this.getSchemaName(schema) || '',
+            displayName: this.getSchemaName(schema) || '',
+            schema
+        }));
+    }
+
+    setEventSchemas(schemas: Record<string, JsonSchema> | JsonSchema[]): void {
+        if (!schemas) {
+            this.eventSchemas = {};
+            return;
+        }
+
+        if (Array.isArray(schemas)) {
+            const map: Record<string, JsonSchema> = {};
+            schemas.forEach((s, i) => {
+                if (!s) return;
+                const name = this.getSchemaName(s) || `Event${i + 1}`;
+                map[name] = s;
+            });
+            this.eventSchemas = map;
+            return;
+        }
+
+        this.eventSchemas = schemas;
+    }
+
+    validate(model: editor.ITextModel): editor.IMarkerData[] {
+        const markers: editor.IMarkerData[] = [];
+        const content = model.getValue();
+
+        // Skip validation if content is empty or only whitespace
+        // This prevents spurious errors when the model is first created before content is loaded
+        if (!content.trim()) {
+            return markers;
+        }
+
+        // Normalize line endings and split
+        const lines = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+
+        // Find the first non-empty, non-comment line
+        let firstNonEmptyLineIndex = 0;
+        let firstLine = '';
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                firstNonEmptyLineIndex = i;
+                firstLine = trimmed;
+                break;
+            }
+        }
+
+        if (!firstLine) {
+            // This should not happen since we already checked for empty content above,
+            // but if it does (content is all comments), just return without error
+            return markers;
+        }
+
+        // Validate first meaningful line - projection declaration
+        // Supports both "projection Name => ReadModel" and ad hoc "projection Name"
+        const projectionWithReadModelMatch = firstLine.match(/^projection\s+([\w.]+)\s*=>\s*([\w.]+)\s*$/);
+        const projectionAdHocMatch = !projectionWithReadModelMatch && firstLine.match(/^projection\s+([\w.]+)\s*$/);
+
+        if (!projectionWithReadModelMatch && !projectionAdHocMatch) {
+            const lineNumber = firstNonEmptyLineIndex + 1;
+            markers.push(this.createError(lineNumber, 1, firstLine.length + 1, 'Projection definition must start with "projection <ProjectionName>" or "projection <ProjectionName> => <ReadModelIdentifier>"'));
+            return markers;
+        }
+
+        let activeSchema: JsonSchema | undefined;
+        let readModelName: string | null = null;
+
+        if (projectionWithReadModelMatch) {
+            readModelName = projectionWithReadModelMatch[2];
+
+            // Validate read model exists in schemas or is a draft
+            const readModelExists = this.resolveReadModelIdentifier(readModelName) !== null;
+            const isDraftReadModel = this.isDraftReadModel(readModelName);
+            const readModelStartColumn = this.getReadModelStartColumn(firstLine, readModelName);
+
+            if (!readModelExists && !isDraftReadModel) {
+                const lineNumber = firstNonEmptyLineIndex + 1;
+                const col = readModelStartColumn;
+                markers.push(this.createError(lineNumber, col, col + readModelName.length, `Read model '${readModelName}' not found`));
+            } else if (isDraftReadModel) {
+                // Show info marker for draft read models - they exist but haven't been saved yet
+                const lineNumber = firstNonEmptyLineIndex + 1;
+                const col = readModelStartColumn;
+                markers.push(this.createInfo(lineNumber, col, col + readModelName.length, `Read model '${readModelName}' is a draft (not yet saved)`));
+            }
+
+            // Get the active read model schema for property validation (check draft first)
+            const isDraft = this.isDraftReadModel(readModelName);
+            const activeReadModel = isDraft ? null : this.resolveReadModelInfo(readModelName);
+            activeSchema = isDraft ? this.draftReadModel!.schema : activeReadModel?.schema;
+        }
+        // For ad hoc projections (no read model), activeSchema stays undefined — property validation is skipped
+
+        // Validate subsequent lines
+        const contextStack: JsonSchema[] = [activeSchema!];
+        const indentStack: number[] = [0]; // Track indentation levels for context
+        let lastIndent = 0;
+
+        // Track event types at each context level to detect duplicates
+        // Each entry in the stack represents events seen at that context level
+        type EventInfo = { lineNumber: number; col: number };
+        const eventContextStack: Map<string, EventInfo>[] = [new Map()];
+
+        for (let i = 1; i < lines.length; i++) {
+            const lineNumber = i + 1;
+            const line = lines[i];
+            const trimmed = line.trim();
+
+            if (!trimmed || trimmed.startsWith('#')) continue;
+
+            // Calculate current indentation
+            const currentIndent = line.search(/\S/);
+
+            // Pop context when dedenting (exiting a children block)
+            while (currentIndent < lastIndent && indentStack.length > 1) {
+                const poppedIndent = indentStack.pop();
+                if (poppedIndent !== undefined && currentIndent < poppedIndent) {
+                    contextStack.pop();
+                    eventContextStack.pop();
+                }
+            }
+            lastIndent = currentIndent;
+
+            // Get the current event context (events seen at this level)
+            const currentEventContext = eventContextStack[eventContextStack.length - 1];
+
+            // Validate event types in from/every blocks
+            const fromMatch = trimmed.match(/^from\s+([\w-]+)/);
+            if (fromMatch) {
+                const eventType = fromMatch[1];
+                const col = line.indexOf(eventType) + 1;
+
+                if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+                    markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+                }
+
+                // Check for duplicate events at this level
+                if (currentEventContext.has(eventType)) {
+                    markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+                } else {
+                    currentEventContext.set(eventType, { lineNumber, col });
+                }
+            }
+
+            // Validate event types in join/remove blocks
+            const eventsMatch = trimmed.match(/^events\s+([\w-]+)/);
+            if (eventsMatch) {
+                const eventType = eventsMatch[1];
+                const col = line.indexOf(eventType) + 1;
+
+                if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+                    markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+                }
+
+                // Check for duplicate events at this level (within join blocks)
+                if (currentEventContext.has(eventType)) {
+                    markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+                } else {
+                    currentEventContext.set(eventType, { lineNumber, col });
+                }
+            }
+
+            const removeWithMatch = trimmed.match(/^remove\s+(?:with|via\s+join\s+on)\s+([\w-]+)/);
+            if (removeWithMatch) {
+                const eventType = removeWithMatch[1];
+                const col = line.indexOf(eventType) + 1;
+
+                if (Object.keys(this.eventSchemas).length > 0 && !this.eventSchemas[eventType]) {
+                    markers.push(this.createError(lineNumber, col, col + eventType.length, `Event type '${eventType}' not found`));
+                }
+
+                // Check for duplicate events at this level
+                if (currentEventContext.has(eventType)) {
+                    markers.push(this.createError(lineNumber, col, col + eventType.length, `Duplicate event type '${eventType}' - event types can only be used once at each level`));
+                } else {
+                    currentEventContext.set(eventType, { lineNumber, col });
+                }
+            }
+
+            // Validate property assignments
+            const assignmentMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+            if (assignmentMatch) {
+                const currentSchema = contextStack[contextStack.length - 1];
+                if (currentSchema?.properties) {
+                    const [, propertyName] = assignmentMatch;
+                    if (!currentSchema.properties[propertyName]) {
+                        const col = line.indexOf(propertyName) + 1;
+                        const schemaName = this.getSchemaName(currentSchema) || 'current schema';
+                        markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' not found in ${schemaName}`));
+                    }
+                }
+            }
+
+            // Validate increment/decrement/count targets
+            const numericOpMatch = trimmed.match(/^(?:increment|decrement|count)\s+(\w+)$/);
+            if (numericOpMatch) {
+                const currentSchema = contextStack[contextStack.length - 1];
+                if (currentSchema?.properties) {
+                    const [, propertyName] = numericOpMatch;
+                    if (!currentSchema.properties[propertyName]) {
+                        const col = line.indexOf(propertyName) + 1;
+                        const schemaName = this.getSchemaName(currentSchema) || 'current schema';
+                        markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' not found in ${schemaName}`));
+                    }
+                }
+            }
+
+            // Validate add/subtract targets
+            const addSubMatch = trimmed.match(/^(?:add|subtract)\s+(\w+)\s+by\s+/);
+            if (addSubMatch) {
+                const currentSchema = contextStack[contextStack.length - 1];
+                if (currentSchema?.properties) {
+                    const [, propertyName] = addSubMatch;
+                    if (!currentSchema.properties[propertyName]) {
+                        const col = line.indexOf(propertyName) + 1;
+                        const schemaName = this.getSchemaName(currentSchema) || 'current schema';
+                        markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' not found in ${schemaName}`));
+                    }
+                }
+            }
+
+            // Validate children references
+            const childrenMatch = trimmed.match(/^children\s+(\w+)\s+identified\s+by\s+/);
+            if (childrenMatch) {
+                const currentSchema = contextStack[contextStack.length - 1];
+                if (currentSchema?.properties) {
+                    const [, propertyName] = childrenMatch;
+                    const prop = currentSchema.properties[propertyName];
+                    if (!prop) {
+                        const col = line.indexOf(propertyName) + 1;
+                        const schemaName = this.getSchemaName(currentSchema) || 'current schema';
+                        markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Collection property '${propertyName}' not found in ${schemaName}`));
+                    } else if (prop.type !== 'array' && !prop.items) {
+                        const col = line.indexOf(propertyName) + 1;
+                        markers.push(this.createWarning(lineNumber, col, col + propertyName.length, `Property '${propertyName}' is not a collection (array) type`));
+                    } else {
+                        // Push child schema onto context stack for validating nested properties
+                        const childSchema = prop.items;
+                        if (childSchema) {
+                            contextStack.push(childSchema);
+                            indentStack.push(currentIndent);
+                            // Push a new event context for the children block
+                            eventContextStack.push(new Map());
+                        }
+                    }
+                }
+            }
+
+            // Validate join references
+            const joinMatch = trimmed.match(/^join\s+(\w+)\s+on\s+(\w+)/);
+            if (joinMatch && activeSchema?.properties) {
+                const [, collectionName, joinProperty] = joinMatch;
+                const collectionProp = activeSchema.properties[collectionName];
+                if (!collectionProp) {
+                    const col = line.indexOf(collectionName) + 1;
+                    markers.push(this.createWarning(lineNumber, col, col + collectionName.length, `Collection property '${collectionName}' not found in read model '${readModelName}'`));
+                } else if (collectionProp.type !== 'array' && !collectionProp.items) {
+                    const col = line.indexOf(collectionName) + 1;
+                    markers.push(this.createWarning(lineNumber, col, col + collectionName.length, `Property '${collectionName}' is not a collection (array) type`));
+                }
+
+                if (!activeSchema.properties[joinProperty]) {
+                    const col = line.indexOf(joinProperty, line.indexOf('on')) + 1;
+                    markers.push(this.createWarning(lineNumber, col, col + joinProperty.length, `Property '${joinProperty}' not found in read model '${readModelName}'`));
+                }
+
+                // Push a new event context for the join block
+                eventContextStack.push(new Map());
+                indentStack.push(currentIndent);
+            }
+
+            // Validate key references for composite keys
+            const keyMatch = trimmed.match(/^key\s+(\w+)\s*$/);
+            if (keyMatch && activeSchema) {
+                const [, keyName] = keyMatch;
+                // Check if it's a composite key type (should exist in definitions or as a property)
+                const isInDefinitions = activeSchema.definitions && activeSchema.definitions[keyName];
+                const isProperty = activeSchema.properties && activeSchema.properties[keyName];
+
+                if (!isInDefinitions && !isProperty && !this.isBuiltInExpression(keyName)) {
+                    const col = line.indexOf(keyName) + 1;
+                    markers.push(this.createWarning(lineNumber, col, col + keyName.length, `Composite key type '${keyName}' not found in read model schema`));
+                }
+            }
+        }
+
+        return markers;
+    }
+
+    private resolveReadModelInfo(readModelToken: string): ReadModelInfo | null {
+        return this.readModels.find(rm => rm.identifier === readModelToken || rm.displayName === readModelToken) || null;
+    }
+
+    private getReadModelStartColumn(firstLine: string, readModelName: string): number {
+        const prefixMatch = firstLine.match(/^\s*projection\s+[\w.]+\s*=>\s*/);
+        if (!prefixMatch) {
+            const fallbackIndex = firstLine.lastIndexOf(readModelName);
+            return (fallbackIndex >= 0 ? fallbackIndex : 0) + 1;
+        }
+        return prefixMatch[0].length + 1;
+    }
+
+    private resolveReadModelIdentifier(readModelToken: string): string | null {
+        if (this.isDraftReadModel(readModelToken)) {
+            return this.draftReadModel!.identifier;
+        }
+        const readModel = this.resolveReadModelInfo(readModelToken);
+        return readModel?.identifier ?? null;
+    }
+
+    private isDraftReadModel(readModelToken: string): boolean {
+        return !!this.draftReadModel && (this.draftReadModel.identifier === readModelToken || this.draftReadModel.displayName === readModelToken);
+    }
+
+    private isBuiltInExpression(text: string): boolean {
+        return text.startsWith('$') || ['true', 'false', 'null'].includes(text);
+    }
+
+    private createError(line: number, startCol: number, endCol: number, message: string): editor.IMarkerData {
+        return {
+            severity: 8, // Error
+            startLineNumber: line,
+            startColumn: startCol,
+            endLineNumber: line,
+            endColumn: endCol,
+            message,
+        };
+    }
+
+    private createWarning(line: number, startCol: number, endCol: number, message: string): editor.IMarkerData {
+        return {
+            severity: 4, // Warning
+            startLineNumber: line,
+            startColumn: startCol,
+            endLineNumber: line,
+            endColumn: endCol,
+            message,
+        };
+    }
+
+    private createInfo(line: number, startCol: number, endCol: number, message: string): editor.IMarkerData {
+        return {
+            severity: 2, // Info (hint) - shows as blue/green squiggly
+            startLineNumber: line,
+            startColumn: startCol,
+            endLineNumber: line,
+            endColumn: endCol,
+            message,
+        };
+    }
+
+    private getSchemaName(schema: JsonSchema): string | undefined {
+        if (schema.name) return schema.name;
+        if (schema.title) return schema.title;
+        if (typeof schema.$id === 'string') {
+            const parts = schema.$id.split('/');
+            return parts[parts.length - 1] || schema.$id;
+        }
+        return undefined;
+    }
+}

package/sub-languages/projection/index.ts

@@ -0,0 +1,223 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type * as Monaco from 'monaco-editor';
+import { configuration, languageId, monarchLanguage } from './language';
+import { CompletionProvider } from './CompletionProvider';
+import { Validator } from './Validator';
+import { HoverProvider } from './HoverProvider';
+import { CodeActionProvider } from './CodeActionProvider';
+
+export interface JsonSchema {
+    title?: string;
+    name?: string;
+    $id?: string;
+    $ref?: string;
+    type?: string;
+    format?: string;
+    description?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    items?: JsonSchema;
+    required?: string[];
+    definitions?: Record<string, JsonSchema>;
+}
+
+export interface JsonSchemaProperty {
+    id?: string;
+    name?: string;
+    type?: string;
+    format?: string;
+    description?: string;
+    items?: JsonSchema;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: boolean;
+    $ref?: string;
+}
+
+export interface ReadModelInfo {
+    identifier: string;
+    displayName: string;
+    schema: JsonSchema;
+}
+
+// Kept as its own type (rather than duplicated inline in the validator and code action
+// provider, as the Chronicle original had it) since both consume the exact same shape.
+export interface DraftReadModelInfo {
+    identifier: string;
+    displayName: string;
+    containerName: string;
+    schema: JsonSchema;
+}
+
+let validator: Validator | undefined;
+let completionProvider: CompletionProvider | undefined;
+let hoverProvider: HoverProvider | undefined;
+let codeActionProvider: CodeActionProvider | undefined;
+let disposables: Monaco.IDisposable[] = [];
+let monacoInstance: typeof Monaco | null = null;
+let isRegistered = false;
+let pendingCreateReadModelCallback: ((readModelName: string) => void) | null = null;
+let pendingEditReadModelCallback: ((readModelName: string, currentSchema: JsonSchema) => void) | null = null;
+
+export function registerProjectionLanguage(monaco: typeof Monaco): { dispose(): void } {
+    if (!isRegistered) {
+        isRegistered = true;
+        monacoInstance = monaco;
+
+        monaco.languages.register({ id: languageId });
+        monaco.languages.setLanguageConfiguration(languageId, configuration);
+        monaco.languages.setMonarchTokensProvider(languageId, monarchLanguage);
+
+        validator = new Validator();
+        completionProvider = new CompletionProvider();
+        hoverProvider = new HoverProvider();
+        codeActionProvider = new CodeActionProvider();
+
+        // Apply pending callbacks if they were set before initialization
+        if (pendingCreateReadModelCallback) {
+            codeActionProvider.setCreateReadModelCallback(pendingCreateReadModelCallback);
+            pendingCreateReadModelCallback = null;
+        }
+        if (pendingEditReadModelCallback) {
+            codeActionProvider.setEditReadModelCallback(pendingEditReadModelCallback);
+            pendingEditReadModelCallback = null;
+        }
+
+        // Register completion provider with helpful trigger characters
+        disposables.push(monaco.languages.registerCompletionItemProvider(languageId, {
+            provideCompletionItems: completionProvider.provideCompletionItems.bind(completionProvider),
+            triggerCharacters: ['.', ' ', '=', '\n', '$'],
+        }));
+
+        // Register hover provider
+        disposables.push(monaco.languages.registerHoverProvider(languageId, {
+            provideHover: hoverProvider.provideHover.bind(hoverProvider),
+        }));
+
+        // Register code action provider
+        disposables.push(monaco.languages.registerCodeActionProvider(languageId, {
+            provideCodeActions: codeActionProvider.provideCodeActions.bind(codeActionProvider),
+        }, {
+            providedCodeActionKinds: ['quickfix']
+        }));
+
+        // Register command for creating read models
+        disposables.push(monaco.editor.registerCommand('pdl.createReadModel', (_accessor: unknown, readModelName: string) => {
+            codeActionProvider?.invokeCreateReadModel(readModelName);
+        }));
+
+        // Register command for editing read models
+        disposables.push(monaco.editor.registerCommand('pdl.editReadModel', (_accessor: unknown, readModelName: string, currentSchema: JsonSchema) => {
+            codeActionProvider?.invokeEditReadModel(readModelName, currentSchema);
+        }));
+
+        // Register validation on model change
+        disposables.push(monaco.editor.onDidCreateModel((model: Monaco.editor.ITextModel) => {
+            if (model.getLanguageId() === languageId) {
+                validateModel(monaco, model);
+                disposables.push(model.onDidChangeContent(() => validateModel(monaco, model)));
+            }
+        }));
+
+        // Validate existing models
+        monaco.editor.getModels().forEach((model: Monaco.editor.ITextModel) => {
+            if (model.getLanguageId() === languageId) {
+                validateModel(monaco, model);
+            }
+        });
+    }
+
+    return { dispose };
+}
+
+function dispose(): void {
+    disposables.forEach((disposable) => disposable.dispose());
+    disposables = [];
+    isRegistered = false;
+    monacoInstance = null;
+}
+
+export function setReadModelSchema(schema: JsonSchema): void {
+    // Backwards compatible single-schema setter
+    validator?.setReadModelSchemas([schema]);
+    completionProvider?.setReadModelSchemas([schema]);
+}
+
+export function setReadModelSchemas(readModels: ReadModelInfo[]): void {
+    validator?.setReadModels(readModels);
+    completionProvider?.setReadModels(readModels);
+    hoverProvider?.setReadModels(readModels);
+    codeActionProvider?.setReadModels(readModels);
+    revalidateAllModels();
+}
+
+export function setCreateReadModelCallback(callback: (readModelName: string) => void): void {
+    if (codeActionProvider) {
+        codeActionProvider.setCreateReadModelCallback(callback);
+    } else {
+        // Store callback for later when the provider is initialized
+        pendingCreateReadModelCallback = callback;
+    }
+}
+
+export function setEditReadModelCallback(callback: (readModelName: string, currentSchema: JsonSchema) => void): void {
+    if (codeActionProvider) {
+        codeActionProvider.setEditReadModelCallback(callback);
+    } else {
+        // Store callback for later when the provider is initialized
+        pendingEditReadModelCallback = callback;
+    }
+}
+
+export function setDraftReadModel(draft: DraftReadModelInfo | null): void {
+    codeActionProvider?.setDraftReadModel(draft);
+    validator?.setDraftReadModel(draft);
+    hoverProvider?.setDraftReadModel(draft);
+    revalidateAllModels();
+}
+
+export function setEventSchemas(eventSchemas: JsonSchema[] | Record<string, JsonSchema>): void {
+    // Normalize either an array of schemas or a keyed record into a record keyed by derived schema name
+    const normalize = (input: JsonSchema[] | Record<string, JsonSchema>): Record<string, JsonSchema> => {
+        if (!input) return {};
+        if (Array.isArray(input)) {
+            const out: Record<string, JsonSchema> = {};
+            input.forEach((s, i) => {
+                if (!s) return;
+                const name = s.title || s.name || (typeof s.$id === 'string' ? s.$id.split('/').pop() : undefined) || `Event${i + 1}`;
+                out[name] = s;
+            });
+            return out;
+        }
+        return input;
+    };
+
+    const normalized = normalize(eventSchemas);
+    validator?.setEventSchemas(normalized);
+    completionProvider?.setEventSchemas(normalized);
+    hoverProvider?.setEventSchemas(normalized);
+    revalidateAllModels();
+}
+
+export function setEventSequences(sequences: string[]): void {
+    completionProvider?.setEventSequences(sequences);
+}
+
+function validateModel(monaco: typeof Monaco, model: Monaco.editor.ITextModel): void {
+    if (validator && !model.isDisposed()) {
+        const markers = validator.validate(model);
+        monaco.editor.setModelMarkers(model, 'pdl-validator', markers);
+    }
+}
+
+function revalidateAllModels(): void {
+    if (monacoInstance) {
+        monacoInstance.editor.getModels().forEach((model: Monaco.editor.ITextModel) => {
+            if (model.getLanguageId() === languageId) {
+                validateModel(monacoInstance!, model);
+            }
+        });
+    }
+}
+
+export { languageId };