Variable mapOperationSubStrictConst

Type Declaration

• • <Safe extends Safeness = "safe", OutType = unknown>(
        startObject: object,
        nodeCallBacks: {
            add?: {
                preVisitor?: (orig: Add) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Add>, orig: Add) => unknown;
            };
            alt?: {
                preVisitor?: (orig: Alt) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Alt>, orig: Alt) => unknown;
            };
            ask?: {
                preVisitor?: (orig: Ask) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Ask>, orig: Ask) => unknown;
            };
            bgp?: {
                preVisitor?: (orig: Bgp) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Bgp>, orig: Bgp) => unknown;
            };
            clear?: {
                preVisitor?: (orig: Clear) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Clear>, orig: Clear) => unknown;
            };
            compositeupdate?: {
                preVisitor?: (orig: CompositeUpdate) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, CompositeUpdate>,
                    orig: CompositeUpdate,
                ) => unknown;
            };
            construct?: {
                preVisitor?: (orig: Construct) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Construct>, orig: Construct) => unknown;
            };
            copy?: {
                preVisitor?: (orig: Copy) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Copy>, orig: Copy) => unknown;
            };
            create?: {
                preVisitor?: (orig: Create) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Create>, orig: Create) => unknown;
            };
            deleteinsert?: {
                preVisitor?: (orig: DeleteInsert) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, DeleteInsert>,
                    orig: DeleteInsert,
                ) => unknown;
            };
            describe?: {
                preVisitor?: (orig: Algebra.Describe) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Describe>,
                    orig: Algebra.Describe,
                ) => unknown;
            };
            distinct?: {
                preVisitor?: (orig: Distinct) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Distinct>, orig: Distinct) => unknown;
            };
            drop?: {
                preVisitor?: (orig: Drop) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Drop>, orig: Drop) => unknown;
            };
            expression?: {
                preVisitor?: (orig: KnownExpression) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, KnownExpression>,
                    orig: KnownExpression,
                ) => unknown;
            };
            extend?: {
                preVisitor?: (orig: Extend) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Extend>, orig: Extend) => unknown;
            };
            filter?: {
                preVisitor?: (orig: Filter) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Filter>, orig: Filter) => unknown;
            };
            from?: {
                preVisitor?: (orig: From) => TransformContext;
                transform?: (copy: SafeWrap<Safe, From>, orig: From) => unknown;
            };
            graph?: {
                preVisitor?: (orig: Graph) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Graph>, orig: Graph) => unknown;
            };
            group?: {
                preVisitor?: (orig: Extract<Nodes, Typed<T>>) => TransformContext;
                transform?: (
                    copy: SafeWrap<
                        Safe,
                        Patch<Opened<Group>, { aggregates: BoundAggregate[] }>,
                    >,
                    orig: Extract<Nodes, Typed<T>>,
                ) => unknown;
            };
            inv?: {
                preVisitor?: (orig: Inv) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Inv>, orig: Inv) => unknown;
            };
            join?: {
                preVisitor?: (orig: Join) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Join>, orig: Join) => unknown;
            };
            leftjoin?: {
                preVisitor?: (orig: LeftJoin) => TransformContext;
                transform?: (copy: SafeWrap<Safe, LeftJoin>, orig: LeftJoin) => unknown;
            };
            link?: {
                preVisitor?: (orig: Link) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Link>, orig: Link) => unknown;
            };
            load?: {
                preVisitor?: (orig: Load) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Load>, orig: Load) => unknown;
            };
            minus?: {
                preVisitor?: (orig: Minus) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Minus>, orig: Minus) => unknown;
            };
            move?: {
                preVisitor?: (orig: Move) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Move>, orig: Move) => unknown;
            };
            nop?: {
                preVisitor?: (orig: Nop) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Nop>, orig: Nop) => unknown;
            };
            nps?: {
                preVisitor?: (orig: Nps) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Nps>, orig: Nps) => unknown;
            };
            OneOrMorePath?: {
                preVisitor?: (orig: OneOrMorePath) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, OneOrMorePath>,
                    orig: OneOrMorePath,
                ) => unknown;
            };
            orderby?: {
                preVisitor?: (orig: OrderBy) => TransformContext;
                transform?: (copy: SafeWrap<Safe, OrderBy>, orig: OrderBy) => unknown;
            };
            path?: {
                preVisitor?: (orig: Path) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Path>, orig: Path) => unknown;
            };
            pattern?: {
                preVisitor?: (orig: Pattern) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Pattern>, orig: Pattern) => unknown;
            };
            project?: {
                preVisitor?: (orig: Project) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Project>, orig: Project) => unknown;
            };
            reduced?: {
                preVisitor?: (orig: Reduced) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Reduced>, orig: Reduced) => unknown;
            };
            seq?: {
                preVisitor?: (orig: Seq) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Seq>, orig: Seq) => unknown;
            };
            service?: {
                preVisitor?: (orig: Service) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Service>, orig: Service) => unknown;
            };
            slice?: {
                preVisitor?: (orig: Slice) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Slice>, orig: Slice) => unknown;
            };
            union?: {
                preVisitor?: (orig: Union) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Union>, orig: Union) => unknown;
            };
            values?: {
                preVisitor?: (orig: Values) => TransformContext;
                transform?: (copy: SafeWrap<Safe, Values>, orig: Values) => unknown;
            };
            ZeroOrMorePath?: {
                preVisitor?: (orig: ZeroOrMorePath) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, ZeroOrMorePath>,
                    orig: ZeroOrMorePath,
                ) => unknown;
            };
            ZeroOrOnePath?: {
                preVisitor?: (orig: ZeroOrOnePath) => TransformContext;
                transform?: (
                    copy: SafeWrap<Safe, ZeroOrOnePath>,
                    orig: ZeroOrOnePath,
                ) => unknown;
            };
        },
        nodeSpecificCallBacks: {
            add?: {};
            alt?: {};
            ask?: {};
            bgp?: {};
            clear?: {};
            compositeupdate?: {};
            construct?: {};
            copy?: {};
            create?: {};
            deleteinsert?: {};
            describe?: {};
            distinct?: {};
            drop?: {};
            expression?: {
                aggregate?: {
                    preVisitor?: (
                        op:
                            | BoundAggregate
                            | Algebra.AggregateExpression
                            | GroupConcatExpression,
                    ) => TransformContext;
                    transform?: (
                        op: SafeWrap<
                            Safe,
                            BoundAggregate
                            | Algebra.AggregateExpression
                            | GroupConcatExpression,
                        >,
                    ) => unknown;
                };
                existence?: {
                    preVisitor?: (op: Algebra.ExistenceExpression) => TransformContext;
                    transform?: (op: SafeWrap<Safe, Algebra.ExistenceExpression>) => unknown;
                };
                named?: {
                    preVisitor?: (op: NamedExpression) => TransformContext;
                    transform?: (op: SafeWrap<Safe, NamedExpression>) => unknown;
                };
                operator?: {
                    preVisitor?: (op: Algebra.OperatorExpression) => TransformContext;
                    transform?: (op: SafeWrap<Safe, Algebra.OperatorExpression>) => unknown;
                };
                term?: {
                    preVisitor?: (op: Algebra.TermExpression) => TransformContext;
                    transform?: (op: SafeWrap<Safe, Algebra.TermExpression>) => unknown;
                };
                wildcard?: {
                    preVisitor?: (op: WildcardExpression) => TransformContext;
                    transform?: (op: SafeWrap<Safe, WildcardExpression>) => unknown;
                };
            };
            extend?: {};
            filter?: {};
            from?: {};
            graph?: {};
            group?: {};
            inv?: {};
            join?: {};
            leftjoin?: {};
            link?: {};
            load?: {};
            minus?: {};
            move?: {};
            nop?: {};
            nps?: {};
            OneOrMorePath?: {};
            orderby?: {};
            path?: {};
            pattern?: {};
            project?: {};
            reduced?: {};
            seq?: {};
            service?: {};
            slice?: {};
            union?: {};
            values?: {};
            ZeroOrMorePath?: {};
            ZeroOrOnePath?: {};
        },
    ): Safe extends "unsafe" ? OutType : unknown

  • Transform a single node (Typed). Similar to this.transformNode but also allowing you to target the subTypes.

    Type Parameters

    • Safe extends Safeness = "safe"
    • OutType = unknown

    Parameters

    • startObject: object

      the object from which we will start the transformation, potentially visiting and transforming its descendants along the way.

    • nodeCallBacks: {
          add?: {
              preVisitor?: (orig: Add) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Add>, orig: Add) => unknown;
          };
          alt?: {
              preVisitor?: (orig: Alt) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Alt>, orig: Alt) => unknown;
          };
          ask?: {
              preVisitor?: (orig: Ask) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Ask>, orig: Ask) => unknown;
          };
          bgp?: {
              preVisitor?: (orig: Bgp) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Bgp>, orig: Bgp) => unknown;
          };
          clear?: {
              preVisitor?: (orig: Clear) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Clear>, orig: Clear) => unknown;
          };
          compositeupdate?: {
              preVisitor?: (orig: CompositeUpdate) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, CompositeUpdate>,
                  orig: CompositeUpdate,
              ) => unknown;
          };
          construct?: {
              preVisitor?: (orig: Construct) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Construct>, orig: Construct) => unknown;
          };
          copy?: {
              preVisitor?: (orig: Copy) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Copy>, orig: Copy) => unknown;
          };
          create?: {
              preVisitor?: (orig: Create) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Create>, orig: Create) => unknown;
          };
          deleteinsert?: {
              preVisitor?: (orig: DeleteInsert) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, DeleteInsert>,
                  orig: DeleteInsert,
              ) => unknown;
          };
          describe?: {
              preVisitor?: (orig: Algebra.Describe) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Describe>,
                  orig: Algebra.Describe,
              ) => unknown;
          };
          distinct?: {
              preVisitor?: (orig: Distinct) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Distinct>, orig: Distinct) => unknown;
          };
          drop?: {
              preVisitor?: (orig: Drop) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Drop>, orig: Drop) => unknown;
          };
          expression?: {
              preVisitor?: (orig: KnownExpression) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, KnownExpression>,
                  orig: KnownExpression,
              ) => unknown;
          };
          extend?: {
              preVisitor?: (orig: Extend) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Extend>, orig: Extend) => unknown;
          };
          filter?: {
              preVisitor?: (orig: Filter) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Filter>, orig: Filter) => unknown;
          };
          from?: {
              preVisitor?: (orig: From) => TransformContext;
              transform?: (copy: SafeWrap<Safe, From>, orig: From) => unknown;
          };
          graph?: {
              preVisitor?: (orig: Graph) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Graph>, orig: Graph) => unknown;
          };
          group?: {
              preVisitor?: (orig: Extract<Nodes, Typed<T>>) => TransformContext;
              transform?: (
                  copy: SafeWrap<
                      Safe,
                      Patch<Opened<Group>, { aggregates: BoundAggregate[] }>,
                  >,
                  orig: Extract<Nodes, Typed<T>>,
              ) => unknown;
          };
          inv?: {
              preVisitor?: (orig: Inv) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Inv>, orig: Inv) => unknown;
          };
          join?: {
              preVisitor?: (orig: Join) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Join>, orig: Join) => unknown;
          };
          leftjoin?: {
              preVisitor?: (orig: LeftJoin) => TransformContext;
              transform?: (copy: SafeWrap<Safe, LeftJoin>, orig: LeftJoin) => unknown;
          };
          link?: {
              preVisitor?: (orig: Link) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Link>, orig: Link) => unknown;
          };
          load?: {
              preVisitor?: (orig: Load) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Load>, orig: Load) => unknown;
          };
          minus?: {
              preVisitor?: (orig: Minus) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Minus>, orig: Minus) => unknown;
          };
          move?: {
              preVisitor?: (orig: Move) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Move>, orig: Move) => unknown;
          };
          nop?: {
              preVisitor?: (orig: Nop) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Nop>, orig: Nop) => unknown;
          };
          nps?: {
              preVisitor?: (orig: Nps) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Nps>, orig: Nps) => unknown;
          };
          OneOrMorePath?: {
              preVisitor?: (orig: OneOrMorePath) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, OneOrMorePath>,
                  orig: OneOrMorePath,
              ) => unknown;
          };
          orderby?: {
              preVisitor?: (orig: OrderBy) => TransformContext;
              transform?: (copy: SafeWrap<Safe, OrderBy>, orig: OrderBy) => unknown;
          };
          path?: {
              preVisitor?: (orig: Path) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Path>, orig: Path) => unknown;
          };
          pattern?: {
              preVisitor?: (orig: Pattern) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Pattern>, orig: Pattern) => unknown;
          };
          project?: {
              preVisitor?: (orig: Project) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Project>, orig: Project) => unknown;
          };
          reduced?: {
              preVisitor?: (orig: Reduced) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Reduced>, orig: Reduced) => unknown;
          };
          seq?: {
              preVisitor?: (orig: Seq) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Seq>, orig: Seq) => unknown;
          };
          service?: {
              preVisitor?: (orig: Service) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Service>, orig: Service) => unknown;
          };
          slice?: {
              preVisitor?: (orig: Slice) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Slice>, orig: Slice) => unknown;
          };
          union?: {
              preVisitor?: (orig: Union) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Union>, orig: Union) => unknown;
          };
          values?: {
              preVisitor?: (orig: Values) => TransformContext;
              transform?: (copy: SafeWrap<Safe, Values>, orig: Values) => unknown;
          };
          ZeroOrMorePath?: {
              preVisitor?: (orig: ZeroOrMorePath) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, ZeroOrMorePath>,
                  orig: ZeroOrMorePath,
              ) => unknown;
          };
          ZeroOrOnePath?: {
              preVisitor?: (orig: ZeroOrOnePath) => TransformContext;
              transform?: (
                  copy: SafeWrap<Safe, ZeroOrOnePath>,
                  orig: ZeroOrOnePath,
              ) => unknown;
          };
      }

      a dictionary mapping the various operation types to objects optionally containing preVisitor and transformer. The preVisitor allows you to provide TransformContext for the current object, altering how it will be transformed. The transformer allows you to manipulate the copy of the current object, and expects you to return the value that should take the current objects place.

    • nodeSpecificCallBacks: {
          add?: {};
          alt?: {};
          ask?: {};
          bgp?: {};
          clear?: {};
          compositeupdate?: {};
          construct?: {};
          copy?: {};
          create?: {};
          deleteinsert?: {};
          describe?: {};
          distinct?: {};
          drop?: {};
          expression?: {
              aggregate?: {
                  preVisitor?: (
                      op:
                          | BoundAggregate
                          | Algebra.AggregateExpression
                          | GroupConcatExpression,
                  ) => TransformContext;
                  transform?: (
                      op: SafeWrap<
                          Safe,
                          BoundAggregate
                          | Algebra.AggregateExpression
                          | GroupConcatExpression,
                      >,
                  ) => unknown;
              };
              existence?: {
                  preVisitor?: (op: Algebra.ExistenceExpression) => TransformContext;
                  transform?: (op: SafeWrap<Safe, Algebra.ExistenceExpression>) => unknown;
              };
              named?: {
                  preVisitor?: (op: NamedExpression) => TransformContext;
                  transform?: (op: SafeWrap<Safe, NamedExpression>) => unknown;
              };
              operator?: {
                  preVisitor?: (op: Algebra.OperatorExpression) => TransformContext;
                  transform?: (op: SafeWrap<Safe, Algebra.OperatorExpression>) => unknown;
              };
              term?: {
                  preVisitor?: (op: Algebra.TermExpression) => TransformContext;
                  transform?: (op: SafeWrap<Safe, Algebra.TermExpression>) => unknown;
              };
              wildcard?: {
                  preVisitor?: (op: WildcardExpression) => TransformContext;
                  transform?: (op: SafeWrap<Safe, WildcardExpression>) => unknown;
              };
          };
          extend?: {};
          filter?: {};
          from?: {};
          graph?: {};
          group?: {};
          inv?: {};
          join?: {};
          leftjoin?: {};
          link?: {};
          load?: {};
          minus?: {};
          move?: {};
          nop?: {};
          nps?: {};
          OneOrMorePath?: {};
          orderby?: {};
          path?: {};
          pattern?: {};
          project?: {};
          reduced?: {};
          seq?: {};
          service?: {};
          slice?: {};
          union?: {};
          values?: {};
          ZeroOrMorePath?: {};
          ZeroOrOnePath?: {};
      }

      Same as nodeCallBacks but using an additional level of indirection to indicate the subType.

    Returns Safe extends "unsafe" ? OutType : unknown

    the result of transforming the requested descendant operations (based on the preVisitor) using a transformer that works its way back up from the descendant to the startObject.