quixos-protocol/grammar/QuixosCapability.g4

grammar QuixosCapability;

document
  : workspaceDecl EOF
  | interfaceResourceDecl EOF
  | packageResourceDecl EOF
  | fragmentDecl EOF
  ;

fragmentDecl
  : FRAGMENT LBRACE workspaceItem* RBRACE
  ;

sourceImportDecl
  : IMPORT stringLiteral SEMI
  ;

workspaceDecl
  : WORKSPACE identifier ID stringLiteral REVISION stringLiteral COMMIT stringLiteral
    LBRACE workspaceItem* RBRACE
  ;

workspaceItem
  : sourceImportDecl
  | atomDecl
  | resourceImportDecl
  | sharedAttachmentDecl
  | conformanceDecl
  | constructorBindingDecl
  | presentationDecl
  | typeAliasDecl
  ;

resourceImportDecl
  : IMPORT INTERFACE identifier SEMI
  | IMPORT PACKAGE identifier SEMI
  ;

externalAtomDecl
  : EXTERNAL ATOM identifier ID stringLiteral SEMI
  ;

externalInterfaceDecl
  : EXTERNAL INTERFACE identifier REVISION stringLiteral SEMI
  ;

resourcePreamble
  : resourceImportDecl
  | externalAtomDecl
  | externalInterfaceDecl
  | typeAliasDecl
  ;

atomDecl
  : ATOM identifier ID stringLiteral (DOC stringLiteral)? SEMI
  ;

interfaceResourceDecl
  : resourcePreamble* INTERFACE identifier typeParameters? ID stringLiteral REVISION stringLiteral
    (REQUIRES interfaceType (COMMA interfaceType)*)?
    LBRACE interfaceMember* RBRACE
  ;

typeParameters
  : LT typeParameter (COMMA typeParameter)* GT
  ;

typeParameter
  : VALUE identifier (COLON STORABLE)?
  | OBJECT identifier (IMPLEMENTS interfaceType (AMP interfaceType)*)?
  ;

interfaceType
  : identifier typeArguments?
  ;

typeArguments
  : LT typeArgument (COMMA typeArgument)* GT
  ;

typeArgument
  : ATOM identifier
  | INTERFACE interfaceType
  | OBJECT identifier
  | valueType
  ;

typeAliasDecl
  : TYPE identifier typeParameters? EQUAL valueType SEMI
  ;

interfaceMember
  : valueMember
  | relationshipMember
  | operationMember
  | moduleMember
  ;

moduleMember
  : MODULE identifier ID stringLiteral CONTRACT stringLiteral (SUBJECT targetConstraint)? SEMI
  ;

operationMember
  : STATIC? OPERATION identifier ID stringLiteral COLON valueType ARROW valueType
    LBRACE CALL ID stringLiteral executionClause? SEMI RBRACE
  ;

valueMember
  : queryReadContract? (VALUE | FIELD) identifier ID stringLiteral COLON valueType
    LBRACE valueMemberOperation* RBRACE
  ;

valueMemberOperation
  : GET ID stringLiteral executionClause? SEMI
  | SET ID stringLiteral executionClause? SEMI
  | EDIT ID stringLiteral executionClause? SEMI
  | WATCH START ID stringLiteral STOP ID stringLiteral SEMI
  ;

relationshipMember
  : queryReadContract? RELATION identifier ID stringLiteral COLON cardinality targetConstraint ORDERED? (KEYED stringLiteral)?
    LBRACE relationshipOperation* RBRACE
  ;

queryReadContract
  : QUERYABLE (RPC | PORTABLE)?
  ;

relationshipOperation
  : RESOLVE ID stringLiteral executionClause? SEMI
  | CONNECT ID stringLiteral executionClause? SEMI
  | DISCONNECT ID stringLiteral executionClause? SEMI
  | WATCH START ID stringLiteral STOP ID stringLiteral SEMI
  ;

targetConstraint
  : ATOM identifier
  | INTERFACE identifier typeArguments?
  | OBJECT identifier
  ;

packageResourceDecl
  : resourcePreamble* PACKAGE identifier ID stringLiteral REVISION stringLiteral
    (SEMANTIC_MAJOR INTEGER)?
    LBRACE packageExport* RBRACE
  ;

packageExport
  : packageOperationExport
  | packageFunctionExport
  | packageConstructorExport
  | packageQuery
  | packageQuerySpecialization
  | moduleExport
  ;

moduleExport
  : MODULE identifier ID stringLiteral IMPLEMENTS interfaceType DOT identifier SEMI
  ;

presentationDecl
  : PRESENTATION identifier ID stringLiteral FOR interfaceType USING identifier DOT identifier SEMI
  ;

packageQuery
  : QUERY FRAGMENT? identifier typeParameters? ID stringLiteral ROOT WORKSPACE? interfaceType
    DOCUMENT stringLiteral
    (OPERATION stringLiteral LBRACE queryClause* RBRACE
    | FRAGMENT stringLiteral (OPERATION stringLiteral)? (LBRACE queryClause* RBRACE | SEMI))
  ;

packageQuerySpecialization
  : QUERY identifier ID stringLiteral SPECIALIZE identifier typeArguments SEMI
  ;

queryClause
  : REPLICA SEMI
  | LOCAL FROM identifier SEMI
  | FRAGMENTS stringLiteral SEMI
  | FRAGMENTS identifier DOT identifier (WITH LBRACE fragmentVariable* RBRACE)? SEMI
  | VIEW OBJECT? identifier AS interfaceType SEMI
  | MAX identifier INTEGER SEMI
  | ALLOW interfaceType DOT identifier identifier stringLiteral SEMI
  | WATCH SEMI
  | POLL INTEGER stringLiteral SEMI
  ;

fragmentVariable : identifier TO identifier SEMI;

packageOperationExport
  : OPERATION identifier typeParameters? ID stringLiteral COLON valueType ARROW valueType
    MODE operationMode executionClause? eventClause? RECEIVER receiverRequirement dependencyBlock? preparationClause? acceptanceClause? SEMI
  ;

packageFunctionExport
  : FUNCTION identifier typeParameters? ID stringLiteral COLON valueType ARROW valueType
    executionClause? dependencyBlock? preparationClause? acceptanceClause? SEMI
  ;

acceptanceClause
  : ACCEPT USING identifier
  ;

preparationClause
  : PREPARES CREATION identifier USING stringLiteral
  ;

executionClause
  : EXECUTION REMOTE
  | EXECUTION (SNAPSHOT | TRANSACTION) TARGETS LBRACK identifierList RBRACK
  ;

selectedOperations
  : USING LBRACK memberOperationRef (COMMA memberOperationRef)* RBRACK
  ;

packageConstructorExport
  : CONSTRUCTOR identifier ID stringLiteral CONSTRUCTS identifier COLON valueType
    dependencyBlock? SEMI
  ;

eventClause
  : EMITS valueType
  ;

operationMode
  : CALL
  | WATCH_START
  | WATCH_STOP
  | SUBSCRIBE
  | UNSUBSCRIBE
  ;

receiverRequirement
  : ANY
  | ATOM identifier
  | OBJECT identifier
  | INTERFACES LBRACK (interfaceType (COMMA interfaceType)*)? RBRACK
  ;

identifierList
  : identifier (COMMA identifier)*
  ;

dependencyBlock
  : REQUIRES LBRACE dependencyPort* RBRACE
  ;

dependencyPort
  : REFLECTION identifier ID stringLiteral LBRACK identifierList RBRACK SEMI
  | STATE identifier ID stringLiteral COLON valueType primitiveList SEMI
  | EDGE identifier ID stringLiteral COLON cardinality targetConstraint (KEYED stringLiteral)? primitiveList SEMI
  | INTERFACE identifier ID stringLiteral COLON identifier typeArguments? selectedOperations? (FROM INPUT)? SEMI
  | CREATION identifier ID stringLiteral COLON identifier INPUT valueType SEMI
  | CONSTRUCTOR identifier ID stringLiteral COLON identifier (INPUT valueType)? SEMI
  | QUERY identifier ID stringLiteral COLON identifier DOT identifier SEMI
  ;

primitiveList
  : LBRACK primitive (COMMA primitive)* RBRACK
  ;

primitive
  : READ
  | WRITE
  | EDIT
  | RESOLVE
  | CONNECT
  | DISCONNECT
  | WATCH_START
  | WATCH_STOP
  ;

sharedAttachmentDecl
  : SHARED attachmentDecl
  ;

attachmentDecl
  : stateDecl
  | edgeDecl
  ;

stateDecl
  : STATE identifier ID stringLiteral ON identifier COLON valueType
    POLICY storagePolicy (DEFAULT jsonLiteral)? SEMI
  ;

storagePolicy
  : REGISTER
  | CRDT LPAREN valueType RPAREN
  | JOURNAL jsonObject
  | SUBSCRIPTION LPAREN valueType RPAREN
  ;

edgeDecl
  : EDGE identifier ID stringLiteral LBRACE edgeEndpoint edgeEndpoint RBRACE
  ;

edgeEndpoint
  : targetConstraint PROJECTION identifier ID stringLiteral cardinality ORDERED?
    (ON_DELETE stringLiteral)? RETAIN_OTHER? (KEYED stringLiteral)? PUBLIC_TRAVERSAL? SEMI
  ;

conformanceDecl
  : CONFORM typeParameters? identifier conformanceSourceArguments? AS identifier typeArguments? (ID stringLiteral)? (SEMANTIC_MAJOR INTEGER)?
    LBRACE conformanceItem* RBRACE
  ;

conformanceSourceArguments
  : typeArguments
  ;

conformanceItem
  : PRIVATE attachmentDecl
  | operationBindingDecl
  | stateFieldBindingDecl
  | initializationDecl
  | relationshipMaterializationDecl
  | moduleBindingDecl
  ;

moduleBindingDecl
  : BIND identifier TO identifier DOT identifier SEMI
  ;

initializationDecl
  : INITIALIZE LBRACE initializationField* RBRACE SEMI
  ;

initializationField
  : identifier TO STATE identifier SEMI
  | identifier TO EDGE identifier DOT identifier SEMI
  ;

creationOwnerMapping
  : interfaceType FROM INPUT (DOT identifier)* SEMI
  ;

stateFieldBindingDecl
  : BIND identifier TO STATE identifier SEMI
  ;

relationshipMaterializationDecl
  : MATERIALIZE identifier IF ABSENT USING CONSTRUCTOR identifier VIA EDGE identifier DOT identifier SEMI
  ;

operationBindingDecl
  : BIND memberOperationRef TO operationProvider (QUERY_REASON stringLiteral)? SEMI
  ;

memberOperationRef
  : identifier DOT operationName
  ;

operationName
  : identifier
  | CALL
  | GET
  | SET
  | EDIT
  | RESOLVE
  | CONNECT
  | DISCONNECT
  | WATCH_START
  | WATCH_STOP
  | SUBSCRIBE
  | UNSUBSCRIBE
  ;

operationProvider
  : LIFECYCLE DOT identifier
  | JOURNAL identifier DOT identifier
  | SUBSCRIPTION identifier DOT identifier
  | STATE identifier DOT statePrimitive
  | EDGE identifier DOT identifier DOT edgePrimitive
  | INTERFACE identifier typeArguments? DOT memberOperationRef
  | PACKAGE identifier DOT identifier typeArguments? dependencyBindingBlock? acceptanceBinding?
  ;

acceptanceBinding
  : ACCEPT dependencyBindingBlock
  ;

statePrimitive
  : READ
  | WRITE
  | EDIT
  | WATCH_START
  | WATCH_STOP
  ;

edgePrimitive
  : RESOLVE
  | CONNECT
  | DISCONNECT
  | WATCH_START
  | WATCH_STOP
  ;

dependencyBindingBlock
  : WITH LBRACE dependencyBinding* RBRACE
  ;

dependencyBinding
  : identifier TO WORKSPACE REFLECTION LBRACK identifierList RBRACK SEMI
  | identifier TO STATE identifier (VIA EDGE identifier DOT identifier)? SEMI
  | identifier TO EDGE identifier DOT identifier (VIA EDGE identifier DOT identifier)? SEMI
  | identifier TO INTERFACE identifier typeArguments? ((VIA EDGE identifier DOT identifier) | (FROM INPUT))? SEMI
  | identifier TO CREATION identifier WITH LBRACE creationOwnerMapping* RBRACE SEMI
  | identifier TO CONSTRUCTOR identifier SEMI
  | identifier TO WORKSPACE? QUERY identifier DOT identifier (VIA EDGE identifier DOT identifier)? SEMI
  ;

constructorBindingDecl
  : CONSTRUCTOR identifier TO identifier DOT identifier dependencyBindingBlock? SEMI
  ;

valueType
  : scalarType
  | UNIT
  | WATCH_HANDLE
  | MESSAGE stringLiteral
  | ATOM_REF LT identifier GT
  | INTERFACE_REF LT identifier typeArguments? GT
  | REF LT identifier GT
  | OPTIONAL LT valueType GT
  | LIST LT valueType GT
  | RECORD LBRACE recordField* RBRACE
  | VARIANT ID stringLiteral LBRACE variantCase+ RBRACE
  | identifier typeArguments?
  ;

recordField
  : identifier COLON valueType SEMI
  ;

variantCase
  : identifier ID stringLiteral COLON valueType SEMI
  ;

scalarType
  : BOOL
  | BYTES
  | DOUBLE
  | INT32
  | INT64
  | STRING
  | UINT32
  | UINT64
  ;

cardinality
  : OPTIONAL_ONE
  | EXACTLY_ONE
  | MANY
  | MANY_UNIQUE
  ;

jsonLiteral
  : stringLiteral
  | INTEGER
  | JSON_NUMBER
  | TRUE
  | FALSE
  | NULL
  | jsonObject
  | jsonArray
  ;

jsonObject
  : LBRACE (jsonMember (COMMA jsonMember)*)? RBRACE
  ;

jsonMember
  : stringLiteral COLON jsonLiteral
  ;

jsonArray
  : LBRACK (jsonLiteral (COMMA jsonLiteral)*)? RBRACK
  ;

identifier
  : IDENTIFIER
  | START
  | STOP
  | EDIT
  | CREATION
  | INITIALIZE
  | EXECUTION
  | SNAPSHOT
  | TRANSACTION
  | REMOTE
  | TARGETS
  | PORTABLE
  | REPLICA
  | LOCAL
  | FROM
  | REGISTER
  | INTERFACES
  | REFLECTION
  | SOURCE
  | QUERY
  | SPECIALIZE
  | ROOT
  | DOCUMENT
  | FRAGMENTS
  | FRAGMENT
  | VIEW
  | MAX
  | ALLOW
  | POLL
  | RPC
  | QUERYABLE
  | RESULT_BYTES
  | RPC_CALLS
  | DEADLINE_MS
  | PRESENTATION
  | SUBJECT
  | MESSAGE
  | JOURNAL
  | SUBSCRIPTION
  | CONNECT
  | FOR
  ;

stringLiteral
  : STRING_LITERAL
  ;

EDIT: 'edit';
MODULE: 'module';
CONTRACT: 'contract';
PRESENTATION: 'presentation';
SUBJECT: 'subject';
FOR: 'for';
CREATION: 'creation';
VARIANT: 'variant';
PREPARES: 'prepares';
INITIALIZE: 'initialize';
WORKSPACE: 'workspace';
EXECUTION: 'execution';
SNAPSHOT: 'snapshot';
TRANSACTION: 'transaction';
REMOTE: 'remote';
TARGETS: 'targets';
PORTABLE: 'portable';
REPLICA: 'replica';
LOCAL: 'local';
FROM: 'from';
RESULT_BYTES: 'result-bytes';
RPC_CALLS: 'rpc-calls';
DEADLINE_MS: 'deadline-ms';
QUERY: 'query';
REFLECTION: 'reflection';
SPECIALIZE: 'specialize';
ROOT: 'root';
DOCUMENT: 'document';
FRAGMENTS: 'fragments';
VIEW: 'view';
MAX: 'max';
ALLOW: 'allow';
POLL: 'poll';
QUERYABLE: 'queryable';
RPC: 'rpc';
QUERY_REASON: 'query-reason';
TYPE: 'type';
OBJECT: 'object';
STORABLE: 'storable';
IMPLEMENTS: 'implements';
REF: 'ref';
FRAGMENT: 'fragment';
IMPORT: 'import';
EXTERNAL: 'external';
ATOM: 'atom';
INTERFACE: 'interface';
INTERFACES: 'interfaces';
PACKAGE: 'package';
VALUE: 'value';
FIELD: 'field';
RELATION: 'relation';
OPERATION: 'operation';
FUNCTION: 'function';
CONSTRUCTOR: 'constructor';
CONSTRUCTS: 'constructs';
INPUT: 'input';
CONFORM: 'conform';
AS: 'as';
BIND: 'bind';
STATIC: 'static';
TO: 'to';
PRIVATE: 'private';
SHARED: 'shared';
STATE: 'state';
EDGE: 'edge';
PROJECTION: 'projection';
WITH: 'with';
USING: 'using';
ACCEPT: 'accept';
VIA: 'via';
MATERIALIZE: 'materialize';
IF: 'if';
ABSENT: 'absent';
ON: 'on';
POLICY: 'policy';
DEFAULT: 'default';
SOURCE: 'source';
REPOSITORY: 'repository';
COMMIT: 'commit';
REVISION: 'revision';
SEMANTIC_MAJOR: 'semantic-major';
ON_DELETE: 'on-delete';
LIFECYCLE: 'lifecycle';
JOURNAL: 'journal';
SUBSCRIPTION: 'subscription';
RETAIN_OTHER: 'retain-other';
KEYED: 'keyed';
PUBLIC_TRAVERSAL: 'public-traversal';
ID: 'id';
DOC: 'doc';
MODE: 'mode';
EMITS: 'emits';
RECEIVER: 'receiver';
REQUIRES: 'requires';
ANY: 'any';
GET: 'get';
SET: 'set';
WATCH: 'watch';
START: 'start';
STOP: 'stop';
READ: 'read';
WRITE: 'write';
RESOLVE: 'resolve';
CONNECT: 'connect';
DISCONNECT: 'disconnect';
CALL: 'call';
WATCH_START: 'watch-start';
WATCH_STOP: 'watch-stop';
SUBSCRIBE: 'subscribe';
UNSUBSCRIBE: 'unsubscribe';
REGISTER: 'register';
CRDT: 'crdt';
OPTIONAL_ONE: 'optional-one';
EXACTLY_ONE: 'exactly-one';
MANY_UNIQUE: 'many-unique';
MANY: 'many';
ORDERED: 'ordered';
UNIT: 'unit';
WATCH_HANDLE: 'watch-handle';
MESSAGE: 'message';
ATOM_REF: 'atom-ref';
INTERFACE_REF: 'interface-ref';
OPTIONAL: 'optional';
LIST: 'list';
RECORD: 'record';
BOOL: 'bool';
BYTES: 'bytes';
DOUBLE: 'double';
INT32: 'int32';
INT64: 'int64';
STRING: 'string';
UINT32: 'uint32';
UINT64: 'uint64';
TRUE: 'true';
FALSE: 'false';
NULL: 'null';

ARROW: '->';
COLON: ':';
SEMI: ';';
COMMA: ',';
DOT: '.';
LBRACE: '{';
RBRACE: '}';
LBRACK: '[';
RBRACK: ']';
LPAREN: '(';
RPAREN: ')';
LT: '<';
GT: '>';
AMP: '&';
EQUAL: '=';

INTEGER: '-'? [0-9]+;
JSON_NUMBER: '-'? ('0' | [1-9] [0-9]*) ('.' [0-9]+)? ([eE] [+-]? [0-9]+)?;
IDENTIFIER: [A-Za-z_] [A-Za-z0-9_]*;
STRING_LITERAL: '"' (ESC | ~["\\\r\n])* '"';
fragment ESC: '\\' (["\\/bfnrt] | 'u' HEX HEX HEX HEX);
fragment HEX: [0-9a-fA-F];

LINE_COMMENT: '//' ~[\r\n]* -> channel(HIDDEN);
BLOCK_COMMENT: '/*' .*? '*/' -> channel(HIDDEN);
WS: [ \t\r\n]+ -> channel(HIDDEN);