@traqula/rules-sparql-1-1 0.0.1-alpha.176 → 0.0.1

package/lib/RoundTripTypes.d.ts

@@ -0,0 +1,379 @@
+import type { Localized, Node } from '@traqula/core';
+export type Sparql11Nodes = GraphRef | UpdateOperation | Update | Query | DatasetClauses | TripleCollection | TripleNesting | Pattern | SolutionModifier | Expression | Path | ContextDefinition | Wildcard | Term;
+export type GraphRefBase = Node & {
+    type: 'graphRef';
+    subType: string;
+};
+export type GraphRefDefault = GraphRefBase & {
+    subType: 'default';
+};
+export type GraphRefNamed = GraphRefBase & {
+    subType: 'named';
+};
+export type GraphRefAll = GraphRefBase & {
+    subType: 'all';
+};
+export type GraphRefSpecific = GraphRefBase & {
+    subType: 'specific';
+    graph: TermIri;
+};
+export type GraphRef = GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific;
+export type Quads = PatternBgp | GraphQuads;
+export type GraphQuads = Node & {
+    type: 'graph';
+    graph: TermIri | TermVariable;
+    triples: PatternBgp;
+};
+export type UpdateOperationBase = Node & {
+    type: 'updateOperation';
+    subType: string;
+};
+export type UpdateOperationLoad = UpdateOperationBase & {
+    subType: 'load';
+    silent: boolean;
+    source: TermIri;
+    destination?: GraphRefSpecific;
+};
+type UpdateOperationClearDropCreateBase = UpdateOperationBase & {
+    subType: 'clear' | 'drop' | 'create';
+    silent: boolean;
+    destination: GraphRef;
+};
+export type UpdateOperationClear = UpdateOperationClearDropCreateBase & {
+    subType: 'clear';
+};
+export type UpdateOperationDrop = UpdateOperationClearDropCreateBase & {
+    subType: 'drop';
+};
+export type UpdateOperationCreate = UpdateOperationClearDropCreateBase & {
+    subType: 'create';
+    destination: GraphRefSpecific;
+};
+type UpdateOperationAddMoveCopy = UpdateOperationBase & {
+    subType: 'add' | 'move' | 'copy';
+    silent: boolean;
+    source: GraphRefDefault | GraphRefSpecific;
+    destination: GraphRefDefault | GraphRefSpecific;
+};
+export type UpdateOperationAdd = UpdateOperationAddMoveCopy & {
+    subType: 'add';
+};
+export type UpdateOperationMove = UpdateOperationAddMoveCopy & {
+    subType: 'move';
+};
+export type UpdateOperationCopy = UpdateOperationAddMoveCopy & {
+    subType: 'copy';
+};
+type UpdateOperationInsertDeleteDelWhere = UpdateOperationBase & {
+    subType: 'insertdata' | 'deletedata' | 'deletewhere';
+    data: Quads[];
+};
+export type UpdateOperationInsertData = UpdateOperationInsertDeleteDelWhere & {
+    subType: 'insertdata';
+};
+export type UpdateOperationDeleteData = UpdateOperationInsertDeleteDelWhere & {
+    subType: 'deletedata';
+};
+export type UpdateOperationDeleteWhere = UpdateOperationInsertDeleteDelWhere & {
+    subType: 'deletewhere';
+};
+export type UpdateOperationModify = UpdateOperationBase & {
+    subType: 'modify';
+    graph: TermIri | undefined;
+    insert: Quads[];
+    delete: Quads[];
+    from: DatasetClauses;
+    where: PatternGroup;
+};
+export type UpdateOperation = UpdateOperationLoad | UpdateOperationClear | UpdateOperationDrop | UpdateOperationCreate | UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy | UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere | UpdateOperationModify;
+export type Update = Node & {
+    type: 'update';
+    updates: {
+        operation?: UpdateOperation;
+        context: ContextDefinition[];
+    }[];
+};
+export type QueryBase = Node & {
+    type: 'query';
+    subType: string;
+    context: ContextDefinition[];
+    values?: PatternValues;
+    solutionModifiers: SolutionModifiers;
+    datasets: DatasetClauses;
+    where?: PatternGroup;
+};
+export type QuerySelect = QueryBase & {
+    subType: 'select';
+    variables: (TermVariable | PatternBind)[] | [Wildcard];
+    distinct?: true;
+    reduced?: true;
+    where: PatternGroup;
+};
+export type QueryConstruct = QueryBase & {
+    subType: 'construct';
+    template: PatternBgp;
+    where: PatternGroup;
+};
+export type QueryDescribe = QueryBase & {
+    subType: 'describe';
+    variables: (TermVariable | TermIri)[] | [Wildcard];
+};
+export type QueryAsk = QueryBase & {
+    subType: 'ask';
+    where: PatternGroup;
+};
+export type Query = QuerySelect | QueryConstruct | QueryDescribe | QueryAsk;
+export type SparqlQuery = Query | Update;
+export type DatasetClauses = Node & {
+    type: 'datasetClauses';
+    clauses: {
+        clauseType: 'default' | 'named';
+        value: TermIri;
+    }[];
+};
+export type TripleCollectionBase = Node & {
+    type: 'tripleCollection';
+    subType: string;
+    triples: TripleNesting[];
+    identifier: Term;
+};
+/**
+ * The subject of the triples does not have a string manifestation.
+ */
+export type TripleCollectionList = TripleCollectionBase & {
+    subType: 'list';
+    identifier: TermBlank;
+};
+/**
+ * Bot subject and predicate of the triples do not have a string manifestation.
+ */
+export type TripleCollectionBlankNodeProperties = TripleCollectionBase & {
+    subType: 'blankNodeProperties';
+    identifier: TermBlank;
+};
+export type TripleCollection = TripleCollectionList | TripleCollectionBlankNodeProperties;
+export type GraphNode = Term | TripleCollection;
+export type TripleNesting = Node & {
+    type: 'triple';
+    subject: GraphNode;
+    predicate: TermIri | TermVariable | Path;
+    object: GraphNode;
+};
+export type PatternBase = Node & {
+    type: 'pattern';
+    subType: string;
+};
+export type PatternFilter = PatternBase & {
+    subType: 'filter';
+    expression: Expression;
+};
+export type PatternMinus = PatternBase & {
+    subType: 'minus';
+    patterns: Pattern[];
+};
+export type PatternGroup = PatternBase & {
+    subType: 'group';
+    patterns: Pattern[];
+};
+export type PatternOptional = PatternBase & {
+    subType: 'optional';
+    patterns: Pattern[];
+};
+export type PatternGraph = PatternBase & {
+    subType: 'graph';
+    name: TermIri | TermVariable;
+    patterns: Pattern[];
+};
+export type PatternUnion = PatternBase & {
+    subType: 'union';
+    patterns: PatternGroup[];
+};
+export type BasicGraphPattern = (TripleNesting | TripleCollection)[];
+export type PatternBgp = PatternBase & {
+    subType: 'bgp';
+    /**
+     * Only the first appearance of a subject and predicate have a string manifestation
+     */
+    triples: BasicGraphPattern;
+};
+export type PatternBind = PatternBase & {
+    subType: 'bind';
+    expression: Expression;
+    variable: TermVariable;
+};
+export type PatternService = PatternBase & {
+    subType: 'service';
+    name: TermIri | TermVariable;
+    silent: boolean;
+    patterns: Pattern[];
+};
+/**
+ * A single list of assignments maps the variable identifier to the value
+ */
+export type ValuePatternRow = Record<string, TermIri | TermLiteral | undefined>;
+export type PatternValues = PatternBase & {
+    subType: 'values';
+    values: ValuePatternRow[];
+};
+export type SubSelect = QuerySelect;
+export type Pattern = PatternBgp | PatternGroup | PatternUnion | PatternOptional | PatternMinus | PatternGraph | PatternService | PatternFilter | PatternBind | PatternValues | SubSelect;
+export type SolutionModifiers = {
+    group?: SolutionModifierGroup;
+    having?: SolutionModifierHaving;
+    order?: SolutionModifierOrder;
+    limitOffset?: SolutionModifierLimitOffset;
+};
+export type SolutionModifierBase = Node & {
+    type: 'solutionModifier';
+    subType: string;
+};
+export type SolutionModifierGroupBind = Localized & {
+    variable: TermVariable;
+    value: Expression;
+};
+export type SolutionModifierGroup = SolutionModifierBase & {
+    subType: 'group';
+    groupings: (Expression | SolutionModifierGroupBind)[];
+};
+export type SolutionModifierHaving = SolutionModifierBase & {
+    subType: 'having';
+    having: Expression[];
+};
+export type Ordering = Localized & {
+    descending: boolean;
+    expression: Expression;
+};
+export type SolutionModifierOrder = SolutionModifierBase & {
+    subType: 'order';
+    orderDefs: Ordering[];
+};
+export type SolutionModifierLimitOffset = SolutionModifierBase & {
+    subType: 'limitOffset';
+    limit: number | undefined;
+    offset: number | undefined;
+};
+export type SolutionModifier = SolutionModifierGroup | SolutionModifierHaving | SolutionModifierOrder | SolutionModifierLimitOffset;
+export type ExpressionBase = Node & {
+    type: 'expression';
+    subType: string;
+};
+type ExpressionAggregateBase = ExpressionBase & {
+    subType: 'aggregate';
+    distinct: boolean;
+    expression: [Expression | Wildcard];
+};
+export type ExpressionAggregateDefault = ExpressionAggregateBase & {
+    expression: [Expression];
+    aggregation: string;
+};
+export type ExpressionAggregateOnWildcard = ExpressionAggregateBase & {
+    expression: [Wildcard];
+    aggregation: string;
+};
+export type ExpressionAggregateSeparator = ExpressionAggregateBase & {
+    expression: [Expression];
+    aggregation: string;
+    separator: string;
+};
+export type ExpressionAggregate = ExpressionAggregateDefault | ExpressionAggregateOnWildcard | ExpressionAggregateSeparator;
+export type ExpressionOperation = ExpressionBase & {
+    subType: 'operation';
+    operator: string;
+    args: Expression[];
+};
+export type ExpressionPatternOperation = ExpressionBase & {
+    subType: 'patternOperation';
+    operator: string;
+    args: PatternGroup;
+};
+export type ExpressionFunctionCall = ExpressionBase & {
+    subType: 'functionCall';
+    function: TermIri;
+    distinct: boolean;
+    args: Expression[];
+};
+export type Expression = ExpressionOperation | ExpressionPatternOperation | ExpressionFunctionCall | ExpressionAggregate | TermIri | TermVariable | TermLiteral;
+export type PropertyPathBase = Node & {
+    type: 'path';
+    subType: string;
+};
+export type PropertyPathChain = PropertyPathBase & {
+    subType: '|' | '/';
+    items: Path[];
+};
+export type PathModified = PropertyPathBase & {
+    subType: '?' | '*' | '+' | '^';
+    items: [Path];
+};
+export type PathNegatedElt = PropertyPathBase & {
+    subType: '^';
+    items: [TermIri];
+};
+export type PathAlternativeLimited = PropertyPathBase & {
+    subType: '|';
+    items: (TermIri | PathNegatedElt)[];
+};
+export type PathNegated = PropertyPathBase & {
+    subType: '!';
+    items: [TermIri | PathNegatedElt | PathAlternativeLimited];
+};
+export type Path = TermIri | PropertyPathChain | PathModified | PathNegated;
+export type PathPure = PropertyPathChain | PathModified | PathNegated;
+export type ContextDefinitionBase_ = Node & {
+    type: 'contextDef';
+    subType: string;
+};
+export type ContextDefinitionPrefix = ContextDefinitionBase_ & {
+    subType: 'prefix';
+    key: string;
+    value: TermIriFull;
+};
+export type ContextDefinitionBase = ContextDefinitionBase_ & {
+    subType: 'base';
+    value: TermIriFull;
+};
+export type ContextDefinition = ContextDefinitionPrefix | ContextDefinitionBase;
+export type Wildcard = Node & {
+    type: 'wildcard';
+};
+export type TermBase = Node & {
+    type: 'term';
+    subType: string;
+};
+export type TermLiteralBase = TermBase & {
+    subType: 'literal';
+    value: string;
+};
+export type TermLiteralStr = TermLiteralBase & {
+    langOrIri: undefined;
+};
+export type TermLiteralLangStr = TermLiteralBase & {
+    langOrIri: string;
+};
+export type TermLiteralTyped = TermLiteralBase & {
+    langOrIri: TermIri;
+};
+export type TermLiteral = TermLiteralStr | TermLiteralLangStr | TermLiteralTyped;
+export type TermVariable = TermBase & {
+    subType: 'variable';
+    value: string;
+};
+export type TermIriBase = TermBase & {
+    subType: 'namedNode';
+};
+export type TermIriFull = TermIriBase & {
+    value: string;
+};
+export type TermIriPrefixed = TermIriBase & {
+    value: string;
+    prefix: string;
+};
+export type TermIri = TermIriFull | TermIriPrefixed;
+export type TermBlank = TermBase & {
+    subType: 'blankNode';
+} & {
+    label: string;
+};
+export type GraphTerm = TermIri | TermBlank | TermLiteral;
+export type Term = GraphTerm | TermVariable;
+export {};

package/lib/RoundTripTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RoundTripTypes.js.map

package/lib/RoundTripTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoundTripTypes.js","sourceRoot":"","sources":["RoundTripTypes.ts"],"names":[],"mappings":"","sourcesContent":["import type { Localized, Node } from '@traqula/core';\n\nexport type Sparql11Nodes =\n  | GraphRef\n  | UpdateOperation\n  | Update\n  | Query\n  | DatasetClauses\n  | TripleCollection\n  | TripleNesting\n  | Pattern\n  | SolutionModifier\n  | Expression\n  | Path\n  | ContextDefinition\n  | Wildcard\n  | Term;\n\nexport type GraphRefBase = Node & {\n  type: 'graphRef';\n  subType: string;\n};\nexport type GraphRefDefault = GraphRefBase & {\n  subType: 'default';\n};\nexport type GraphRefNamed = GraphRefBase & {\n  subType: 'named';\n};\nexport type GraphRefAll = GraphRefBase & {\n  subType: 'all';\n};\nexport type GraphRefSpecific = GraphRefBase & {\n  subType: 'specific';\n  graph: TermIri;\n};\nexport type GraphRef =\n  | GraphRefDefault\n  | GraphRefNamed\n  | GraphRefAll\n  | GraphRefSpecific;\n\nexport type Quads = PatternBgp | GraphQuads;\n\nexport type GraphQuads = Node & {\n  type: 'graph';\n  graph: TermIri | TermVariable;\n  triples: PatternBgp;\n};\n\n// https://www.w3.org/TR/sparql11-query/#rUpdate1\nexport type UpdateOperationBase = Node & { type: 'updateOperation'; subType: string };\nexport type UpdateOperationLoad = UpdateOperationBase & {\n  subType: 'load';\n  silent: boolean;\n  source: TermIri;\n  destination?: GraphRefSpecific;\n};\ntype UpdateOperationClearDropCreateBase = UpdateOperationBase & {\n  subType: 'clear' | 'drop' | 'create';\n  silent: boolean;\n  destination: GraphRef;\n};\nexport type UpdateOperationClear = UpdateOperationClearDropCreateBase & { subType: 'clear' };\nexport type UpdateOperationDrop = UpdateOperationClearDropCreateBase & { subType: 'drop' };\nexport type UpdateOperationCreate = UpdateOperationClearDropCreateBase & {\n  subType: 'create';\n  destination: GraphRefSpecific;\n};\ntype UpdateOperationAddMoveCopy = UpdateOperationBase & {\n  subType: 'add' | 'move' | 'copy';\n  silent: boolean;\n  source: GraphRefDefault | GraphRefSpecific;\n  destination: GraphRefDefault | GraphRefSpecific;\n};\nexport type UpdateOperationAdd = UpdateOperationAddMoveCopy & { subType: 'add' };\nexport type UpdateOperationMove = UpdateOperationAddMoveCopy & { subType: 'move' };\nexport type UpdateOperationCopy = UpdateOperationAddMoveCopy & { subType: 'copy' };\ntype UpdateOperationInsertDeleteDelWhere = UpdateOperationBase & {\n  subType: 'insertdata' | 'deletedata' | 'deletewhere';\n  data: Quads[];\n};\nexport type UpdateOperationInsertData = UpdateOperationInsertDeleteDelWhere & { subType: 'insertdata' };\nexport type UpdateOperationDeleteData = UpdateOperationInsertDeleteDelWhere & { subType: 'deletedata' };\nexport type UpdateOperationDeleteWhere = UpdateOperationInsertDeleteDelWhere & { subType: 'deletewhere' };\nexport type UpdateOperationModify = UpdateOperationBase & {\n  subType: 'modify';\n  graph: TermIri | undefined;\n  insert: Quads[];\n  delete: Quads[];\n  from: DatasetClauses;\n  where: PatternGroup;\n};\nexport type UpdateOperation =\n  | UpdateOperationLoad\n  | UpdateOperationClear\n  | UpdateOperationDrop\n  | UpdateOperationCreate\n  | UpdateOperationAdd\n  | UpdateOperationMove\n  | UpdateOperationCopy\n  | UpdateOperationInsertData\n  | UpdateOperationDeleteData\n  | UpdateOperationDeleteWhere\n  | UpdateOperationModify;\n\n// https://www.w3.org/TR/sparql11-query/#rUpdate\nexport type Update = Node & {\n  type: 'update';\n  updates: {\n    operation?: UpdateOperation;\n    context: ContextDefinition[];\n  }[];\n};\n\n// https://www.w3.org/TR/sparql11-query/#rQueryUnit\nexport type QueryBase = Node & {\n  type: 'query';\n  subType: string;\n\n  context: ContextDefinition[];\n  values?: PatternValues;\n  solutionModifiers: SolutionModifiers;\n  datasets: DatasetClauses;\n  where?: PatternGroup;\n};\nexport type QuerySelect = QueryBase & {\n  subType: 'select';\n  variables: (TermVariable | PatternBind)[] | [Wildcard];\n  distinct?: true;\n  reduced?: true;\n  where: PatternGroup;\n};\nexport type QueryConstruct = QueryBase & {\n  subType: 'construct';\n  template: PatternBgp;\n  where: PatternGroup;\n};\nexport type QueryDescribe = QueryBase & {\n  subType: 'describe';\n  variables: (TermVariable | TermIri)[] | [Wildcard];\n};\nexport type QueryAsk = QueryBase & {\n  subType: 'ask';\n  where: PatternGroup;\n};\nexport type Query =\n  | QuerySelect\n  | QueryConstruct\n  | QueryDescribe\n  | QueryAsk;\n\nexport type SparqlQuery = Query | Update;\n\n// https://www.w3.org/TR/sparql11-query/#rDatasetClause\nexport type DatasetClauses = Node & {\n  type: 'datasetClauses';\n  clauses: { clauseType: 'default' | 'named'; value: TermIri }[];\n};\n\n// https://www.w3.org/TR/sparql11-query/#rGraphNode\nexport type TripleCollectionBase = Node & {\n  type: 'tripleCollection';\n  subType: string;\n  triples: TripleNesting[];\n  identifier: Term;\n};\n/**\n * The subject of the triples does not have a string manifestation.\n */\nexport type TripleCollectionList = TripleCollectionBase & {\n  subType: 'list';\n  identifier: TermBlank;\n};\n/**\n * Bot subject and predicate of the triples do not have a string manifestation.\n */\nexport type TripleCollectionBlankNodeProperties = TripleCollectionBase & {\n  subType: 'blankNodeProperties';\n  identifier: TermBlank;\n};\nexport type TripleCollection =\n  | TripleCollectionList\n  | TripleCollectionBlankNodeProperties;\n\n// https://www.w3.org/TR/sparql11-query/#rGraphNode\nexport type GraphNode = Term | TripleCollection;\n\n// https://www.w3.org/TR/sparql11-query/#rTriplesBlock\nexport type TripleNesting = Node & {\n  type: 'triple';\n  subject: GraphNode;\n  predicate: TermIri | TermVariable | Path;\n  object: GraphNode;\n};\n\nexport type PatternBase = Node & { type: 'pattern'; subType: string };\nexport type PatternFilter = PatternBase & {\n  subType: 'filter';\n  expression: Expression;\n};\nexport type PatternMinus = PatternBase & {\n  subType: 'minus';\n  patterns: Pattern[];\n};\n\nexport type PatternGroup = PatternBase & {\n  subType: 'group';\n  patterns: Pattern[];\n};\nexport type PatternOptional = PatternBase & {\n  subType: 'optional';\n  patterns: Pattern[];\n};\nexport type PatternGraph = PatternBase & {\n  subType: 'graph';\n  name: TermIri | TermVariable;\n  patterns: Pattern[];\n};\nexport type PatternUnion = PatternBase & {\n  subType: 'union';\n  patterns: PatternGroup[];\n};\nexport type BasicGraphPattern = (TripleNesting | TripleCollection)[];\nexport type PatternBgp = PatternBase & {\n  subType: 'bgp';\n  /**\n   * Only the first appearance of a subject and predicate have a string manifestation\n   */\n  triples: BasicGraphPattern;\n};\nexport type PatternBind = PatternBase & {\n  subType: 'bind';\n  expression: Expression;\n  variable: TermVariable;\n};\nexport type PatternService = PatternBase & {\n  subType: 'service';\n  name: TermIri | TermVariable;\n  silent: boolean;\n  patterns: Pattern[];\n};\n/**\n * A single list of assignments maps the variable identifier to the value\n */\nexport type ValuePatternRow = Record<string, TermIri | TermLiteral | undefined>;\nexport type PatternValues = PatternBase & {\n  subType: 'values';\n  values: ValuePatternRow[];\n};\nexport type SubSelect = QuerySelect;\n\nexport type Pattern =\n  | PatternBgp\n  | PatternGroup\n  | PatternUnion\n  | PatternOptional\n  | PatternMinus\n  | PatternGraph\n  | PatternService\n  | PatternFilter\n  | PatternBind\n  | PatternValues\n  | SubSelect;\n\nexport type SolutionModifiers = {\n  group?: SolutionModifierGroup;\n  having?: SolutionModifierHaving;\n  order?: SolutionModifierOrder;\n  limitOffset?: SolutionModifierLimitOffset;\n};\nexport type SolutionModifierBase = Node & { type: 'solutionModifier'; subType: string };\nexport type SolutionModifierGroupBind = Localized & {\n  variable: TermVariable;\n  value: Expression;\n};\nexport type SolutionModifierGroup = SolutionModifierBase & {\n  subType: 'group';\n  groupings: (Expression | SolutionModifierGroupBind)[];\n};\nexport type SolutionModifierHaving = SolutionModifierBase & {\n  subType: 'having';\n  having: Expression[];\n};\nexport type Ordering = Localized & {\n  descending: boolean;\n  expression: Expression;\n};\nexport type SolutionModifierOrder = SolutionModifierBase & {\n  subType: 'order';\n  orderDefs: Ordering[];\n};\nexport type SolutionModifierLimitOffset = SolutionModifierBase\n  & { subType: 'limitOffset'; limit: number | undefined; offset: number | undefined };\n\nexport type SolutionModifier =\n  | SolutionModifierGroup\n  | SolutionModifierHaving\n  | SolutionModifierOrder\n  | SolutionModifierLimitOffset;\n\nexport type ExpressionBase = Node & { type: 'expression'; subType: string };\n\ntype ExpressionAggregateBase = ExpressionBase & {\n  subType: 'aggregate';\n  distinct: boolean;\n  expression: [Expression | Wildcard];\n};\nexport type ExpressionAggregateDefault = ExpressionAggregateBase & {\n  expression: [Expression];\n  aggregation: string;\n};\nexport type ExpressionAggregateOnWildcard = ExpressionAggregateBase & {\n  expression: [Wildcard];\n  aggregation: string;\n};\nexport type ExpressionAggregateSeparator = ExpressionAggregateBase & {\n  expression: [Expression];\n  aggregation: string;\n  separator: string;\n};\nexport type ExpressionAggregate =\n  | ExpressionAggregateDefault\n  | ExpressionAggregateOnWildcard\n  | ExpressionAggregateSeparator;\n\nexport type ExpressionOperation = ExpressionBase & {\n  subType: 'operation';\n  operator: string;\n  args: Expression[];\n};\n\nexport type ExpressionPatternOperation = ExpressionBase & {\n  subType: 'patternOperation';\n  operator: string;\n  // Can be a pattern in case of exists and not exists\n  args: PatternGroup;\n};\n\nexport type ExpressionFunctionCall = ExpressionBase & {\n  subType: 'functionCall';\n  function: TermIri;\n  distinct: boolean;\n  args: Expression[];\n};\n\nexport type Expression =\n  | ExpressionOperation\n  | ExpressionPatternOperation\n  | ExpressionFunctionCall\n  | ExpressionAggregate\n  | TermIri\n  | TermVariable\n  | TermLiteral;\n\nexport type PropertyPathBase = Node & { type: 'path'; subType: string };\nexport type PropertyPathChain = PropertyPathBase & {\n  subType: '|' | '/';\n  items: Path[];\n};\n\nexport type PathModified = PropertyPathBase & {\n  subType: '?' | '*' | '+' | '^';\n  items: [Path];\n};\n\nexport type PathNegatedElt = PropertyPathBase & {\n  subType: '^';\n  items: [TermIri];\n};\n\nexport type PathAlternativeLimited = PropertyPathBase & {\n  subType: '|';\n  items: (TermIri | PathNegatedElt)[];\n};\n\nexport type PathNegated = PropertyPathBase & {\n  subType: '!';\n  items: [TermIri | PathNegatedElt | PathAlternativeLimited];\n};\n\n// [[88]](https://www.w3.org/TR/sparql11-query/#rPath)\nexport type Path =\n  | TermIri\n  | PropertyPathChain\n  | PathModified\n  | PathNegated;\nexport type PathPure = PropertyPathChain | PathModified | PathNegated;\n\nexport type ContextDefinitionBase_ = Node & { type: 'contextDef'; subType: string };\nexport type ContextDefinitionPrefix = ContextDefinitionBase_ & {\n  subType: 'prefix';\n  key: string;\n  value: TermIriFull;\n};\nexport type ContextDefinitionBase = ContextDefinitionBase_ & {\n  subType: 'base';\n  value: TermIriFull;\n};\nexport type ContextDefinition = ContextDefinitionPrefix | ContextDefinitionBase;\n\nexport type Wildcard = Node & {\n  type: 'wildcard';\n};\n\nexport type TermBase = Node & { type: 'term'; subType: string };\nexport type TermLiteralBase = TermBase & {\n  subType: 'literal';\n  value: string;\n};\nexport type TermLiteralStr = TermLiteralBase & { langOrIri: undefined };\nexport type TermLiteralLangStr = TermLiteralBase & { langOrIri: string };\nexport type TermLiteralTyped = TermLiteralBase & { langOrIri: TermIri };\nexport type TermLiteral = TermLiteralStr | TermLiteralLangStr | TermLiteralTyped;\n\nexport type TermVariable = TermBase & {\n  subType: 'variable';\n  value: string;\n};\n\nexport type TermIriBase = TermBase & { subType: 'namedNode' };\nexport type TermIriFull = TermIriBase & { value: string };\nexport type TermIriPrefixed = TermIriBase & {\n  value: string;\n  prefix: string;\n};\nexport type TermIri = TermIriFull | TermIriPrefixed;\n\nexport type TermBlank = TermBase & { subType: 'blankNode' } & { label: string };\n\nexport type GraphTerm = TermIri | TermBlank | TermLiteral;\nexport type Term = GraphTerm | TermVariable;\n"]}

package/lib/Sparql11types.d.ts

@@ -1,248 +1,20 @@
-import type * as RDF from '@rdfjs/types';
-import type { ParserRule, GeneratorRule } from '@traqula/core';
-import type { BlankNode, DataFactory } from 'rdf-data-factory';
-import type { CommonIRIs } from './grammar-helpers/utils';
-import type { Wildcard } from './Wildcard';
-type RdfJsTerm = Term | BaseQuadTerm;
-export type BaseQuadTerm = RDF.BaseQuad & {
-    subject: RdfJsTerm;
-    predicate: RdfJsTerm;
-    object: RdfJsTerm;
-};
-export type GraphTerm = IriTerm | BlankTerm | LiteralTerm;
-export type Term = GraphTerm | VariableTerm;
-export type VerbA = IriTerm<CommonIRIs.TYPE>;
-export type Triple = {
-    subject: Term;
-    predicate: IriTerm | VariableTerm | PropertyPath;
-    object: Term;
-};
-export interface IGraphNode {
-    node: ITriplesNode['node'] | Term;
-    triples: Triple[];
-}
-export interface ITriplesNode {
-    node: IriTerm | BlankNode;
-    triples: Triple[];
-}
-export type Pattern = BgpPattern | BlockPattern | FilterPattern | BindPattern | ValuesPattern | Omit<SelectQuery, 'prefixes'>;
-export type Expression = OperationExpression | FunctionCallExpression | AggregateExpression | Expression[] | IriTerm | VariableTerm | LiteralTerm;
-export interface FunctionCallExpression extends BaseExpression {
-    type: 'functionCall';
-    function: IriTerm;
-    args: Expression[];
-}
+import type { GeneratorRule, ParserRule } from '@traqula/core';
+import type { Factory } from './factory';
+export type SparqlRule<
 /**
- * Basic Graph Pattern
+ * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
  */
-export interface BgpPattern {
-    type: 'bgp';
-    triples: Triple[];
-}
-export interface GraphQuads {
-    type: 'graph';
-    name: IriTerm | VariableTerm;
-    triples: Triple[];
-}
-export type VariableTerm = RDF.Variable;
-export type IriTerm<IRI extends string = string> = RDF.NamedNode<IRI>;
-export type LiteralTerm = RDF.Literal;
-export type BlankTerm = RDF.BlankNode;
-export type PropertyPath = NegatedPropertySet | {
-    type: 'path';
-    pathType: '|' | '/' | '^' | '+' | '*' | '?';
-    items: (IriTerm | PropertyPath)[];
-};
-export type SparqlQuery = Query | Update | Pick<Update, 'base' | 'prefixes'>;
-export type Query = SelectQuery | ConstructQuery | AskQuery | DescribeQuery;
-export interface SelectQuery extends BaseQuery {
-    queryType: 'SELECT';
-    variables: Variable[] | [Wildcard];
-    distinct?: true | undefined;
-    reduced?: true | undefined;
-}
-export interface Grouping {
-    expression: Expression;
-    variable?: VariableTerm;
-}
-export interface Ordering {
-    expression: Expression;
-    descending?: true | undefined;
-}
-export interface ConstructQuery extends BaseQuery {
-    queryType: 'CONSTRUCT';
-    template?: Triple[] | undefined;
-}
-export interface AskQuery extends BaseQuery {
-    queryType: 'ASK';
-}
-export interface DescribeQuery extends BaseQuery {
-    queryType: 'DESCRIBE';
-    variables: (VariableTerm | IriTerm)[] | [Wildcard];
-}
-export interface Update {
-    type: 'update';
-    base?: string | undefined;
-    prefixes: Record<string, string>;
-    updates: UpdateOperation[];
-}
-export type UpdateOperation = InsertDeleteOperation | ManagementOperation;
-export type InsertDeleteOperation = InsertOperation | DeleteOperation | ModifyOperation | DeleteWhereOperation;
-export interface InsertOperation {
-    updateType: 'insert';
-    insert: Quads[];
-}
-export interface DeleteOperation {
-    updateType: 'delete';
-    delete: Quads[];
-}
-export interface ModifyOperation {
-    updateType: 'insertdelete';
-    insert: Quads[];
-    delete: Quads[];
-    graph?: IriTerm;
-    using?: {
-        default: IriTerm[];
-        named: IriTerm[];
-    };
-    where: Pattern[];
-}
-export interface DeleteWhereOperation {
-    updateType: 'deletewhere';
-    delete: Quads[];
-}
-export type Quads = BgpPattern | GraphQuads;
-export type ManagementOperation = CopyMoveAddOperation | LoadOperation | CreateOperation | ClearDropOperation;
-export interface CopyMoveAddOperation {
-    type: 'copy' | 'move' | 'add';
-    silent: boolean;
-    source: GraphOrDefault;
-    destination: GraphOrDefault;
-}
-export interface LoadOperation {
-    type: 'load';
-    silent: boolean;
-    source: IriTerm;
-    destination?: IriTerm;
-}
-export interface CreateOperation {
-    type: 'create';
-    silent: boolean;
-    graph: GraphOrDefault;
-}
-export interface ClearDropOperation {
-    type: 'clear' | 'drop';
-    silent: boolean;
-    graph: GraphReference;
-}
-export interface GraphOrDefault {
-    type?: 'graph';
-    name?: IriTerm | undefined;
-    default?: true | undefined;
-}
-export interface GraphReference extends GraphOrDefault {
-    named?: true | undefined;
-    all?: true | undefined;
-}
+NameType extends string = string, 
 /**
- * Examples: '?var', '*',
- *   SELECT (?a as ?b) ... ==> { expression: '?a', variable: '?b' }
+ * Type that will be returned after a correct parse of this rule.
+ * This type will be the return type of calling SUBRULE with this grammar rule.
  */
-export type Variable = VariableExpression | VariableTerm;
-export interface VariableExpression {
-    expression: Expression;
-    variable: VariableTerm;
-}
-export interface BaseQuery {
-    type: 'query';
-    base?: string | undefined;
-    prefixes: Record<string, string>;
-    from?: {
-        default: IriTerm[];
-        named: IriTerm[];
-    } | undefined;
-    where?: Pattern[] | undefined;
-    values?: ValuePatternRow[] | undefined;
-    having?: Expression[] | undefined;
-    group?: Grouping[] | undefined;
-    order?: Ordering[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-}
-export type IriTermOrElt = IriTerm | {
-    type: 'path';
-    pathType: '^';
-    items: [IriTerm];
-};
-export interface NegatedPropertySet {
-    type: 'path';
-    pathType: '!';
-    items: [IriTermOrElt] | [
-        {
-            type: 'path';
-            pathType: '|';
-            items: (IriTermOrElt)[];
-        }
-    ];
-}
-export interface GroupPattern {
-    type: 'group';
-    patterns: Pattern[];
-}
-export interface GraphPattern {
-    type: 'graph';
-    name: IriTerm | VariableTerm;
-    patterns: Pattern[];
-}
-export interface MinusPattern {
-    type: 'minus';
-    patterns: Pattern[];
-}
-export interface ServicePattern {
-    type: 'service';
-    name: IriTerm | VariableTerm;
-    silent: boolean;
-    patterns: Pattern[];
-}
-export type BlockPattern = OptionalPattern | UnionPattern | GroupPattern | GraphPattern | MinusPattern | ServicePattern;
-export interface OptionalPattern {
-    type: 'optional';
-    patterns: Pattern[];
-}
-export interface UnionPattern {
-    type: 'union';
-    patterns: Pattern[];
-}
-export type ValuePatternRow = Record<string, IriTerm | BlankTerm | LiteralTerm | undefined>;
-export interface FilterPattern {
-    type: 'filter';
-    expression: Expression;
-}
-export interface BindPattern {
-    type: 'bind';
-    expression: Expression;
-    variable: VariableTerm;
-}
-export interface ValuesPattern {
-    type: 'values';
-    values: ValuePatternRow[];
-}
-export interface BaseExpression {
-    type: string;
-    distinct?: boolean | undefined;
-}
-export interface OperationExpression extends BaseExpression {
-    type: 'operation';
-    operator: string;
-    args: (Expression)[] | [Pattern];
-}
-export interface AggregateExpression extends BaseExpression {
-    type: 'aggregate';
-    expression: Expression | Wildcard;
-    aggregation: string;
-    separator?: string | undefined;
-}
-export type SparqlRule<
+ReturnType = unknown, GenInputType = ReturnType, 
+/**
+ * Function arguments that can be given to convey the state of the current parse operation.
+ */
+ParamType = undefined> = SparqlGrammarRule<NameType, ReturnType, ParamType> & SparqlGeneratorRule<NameType, GenInputType, ParamType>;
+export type SparqlGeneratorRule<
 /**
  * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
  */
@@ -255,7 +27,9 @@ ReturnType = unknown,
 /**
  * Function arguments that can be given to convey the state of the current parse operation.
  */
-ParamType = undefined> = ParserRule<SparqlContext, NameType, ReturnType, ParamType> & GeneratorRule<undefined, NameType, ReturnType, ParamType>;
+ParamType = undefined> = GeneratorRule<{
+    factory: Factory;
+}, NameType, ReturnType, ParamType>;
 export type SparqlGrammarRule<
 /**
  * Name of grammar rule, should be a strict subtype of string like 'myGrammarRule'.
@@ -272,9 +46,9 @@ ReturnType = unknown,
 ParamType = undefined> = ParserRule<SparqlContext, NameType, ReturnType, ParamType>;
 export interface SparqlContext {
     /**
-     * Data-factory to be used when constructing rdf primitives.
+     * Data-factoryMixins to be used when constructing rdf primitives.
      */
-    dataFactory: DataFactory<BaseQuadTerm>;
+    factory: Factory;
     /**
      * Current scoped prefixes. Used for resolving prefixed names.
      */
@@ -292,4 +66,3 @@ export interface SparqlContext {
      */
     parseMode: Set<'canParseVars' | 'canCreateBlankNodes' | 'inAggregate' | 'canParseAggregate' | string>;
 }
-export {};