mad-data-parser 0.0.1 → 0.0.2-beta.12

package/src/parser/parseJsonPaths.ts

@@ -1,136 +0,0 @@
-import { getNamedType, GraphQLSchema, isObjectType, isUnionType } from "graphql"
-import type { DocumentNode, GraphQLObjectType, GraphQLOutputType, SelectionSetNode, FragmentDefinitionNode, FieldNode, InlineFragmentNode } from "graphql"
-
-import { createFieldNode, createInlineFragment, findFieldNode, isPrimitiveType } from "~/utils/graphql"
-import { Kind } from "graphql"
-import * as JSONPath from '~/utils/jsonPath'
-
-
-type StackItem = {type: GraphQLOutputType, selectionSet: SelectionSetNode, parent: StackItem|null}
-const typeNameFieldNode = createFieldNode('__typename')
-
-export function parseJsonPaths(jsonPaths:Array<JSONPath.ASTNode[]>, rootType: GraphQLObjectType, fragmentName?: string): DocumentNode {  
-  fragmentName = fragmentName ?? `autoGen${rootType.name}`
-  
-  const rootFragment:FragmentDefinitionNode = {
-    kind: Kind.FRAGMENT_DEFINITION,
-    typeCondition: { kind: Kind.NAMED_TYPE, name: { kind: Kind.NAME, value: rootType.name } },
-    name: { kind: Kind.NAME, value: fragmentName },
-    selectionSet: {
-        kind: Kind.SELECTION_SET,
-        selections: [typeNameFieldNode],
-    } satisfies SelectionSetNode,
-  }
-  
-  const doc: DocumentNode = {
-    kind: Kind.DOCUMENT,
-    definitions: [rootFragment],
-  }
-  const stack: Array<StackItem[]> = []
-  const visitor: JSONPath.NodeVisitor = {   
-    Root() {      
-      stack.push([{type: rootType, selectionSet: rootFragment.selectionSet!, parent: null}])
-      return
-    },
-    Identifier(node) {
-      const stackItems = stack[stack.length - 1]!
-      const passStackItems = processStackItems(stackItems, {fieldName: node.expression.value!, value: undefined, condition: undefined})
-      stack.push(passStackItems)     
-      return
-    },
-    FilterExpression(node) {      
-      const stackItems = stack[stack.length - 1]!
-      const regex = /\?\(@\.(?<field>\w+)(\s*(?<condition>(?:==|!=)=?)\s*(?<quote>'|")(?<value>.*?)(\4))?/
-      const matches = node.expression.value!.match(regex)      
-      const fieldName = matches?.groups?.field ?? '__typename'
-      const condition = matches?.groups?.condition
-      const value = matches?.groups?.value
-      const passStackItems = processStackItems(stackItems, {fieldName, value, condition})      
-      stack.push(passStackItems)
-      return
-    },
-    leave(node, parent, path, ancestors) {      
-      if(needProcess(node)) {        
-        stack.pop()
-      }
-    }
-  }
-  JSONPath.visit(jsonPaths, visitor)
-  return doc
-}
-
-function needProcess(node:JSONPath.ASTNode):boolean {
-  return JSONPath.isRootNode(node) || JSONPath.isIdentifierNode(node) || JSONPath.isFilterExpressionNode(node)
-}
-
-
-
-
-function processStackItems(stackItems: StackItem[], {fieldName, value, condition}: {fieldName: string, value?: string, condition?: string}) {
-  const passStackItems: StackItem[] = []
-  stackItems.forEach(stackItem => {
-    const parentType = stackItem.type
-    if(isPrimitiveType(parentType)) {
-      return
-    }
-    const selSet = stackItem.selectionSet
-    if (isUnionType(parentType)) {
-      const filterField = (type: GraphQLObjectType) => fieldName === '__typename'? type.name === value : Boolean(type.getFields()[fieldName!])
-      const filter = condition && !condition.includes('!') 
-        ? (type: GraphQLObjectType) => filterField(type)
-        : (type: GraphQLObjectType) => !filterField(type)
-      const possibleTypes = parentType.getTypes().filter(filter)            
-      possibleTypes.forEach(type => {          
-        let inlineFragment:InlineFragmentNode|undefined = selSet.selections.find(
-            selection => selection.kind === Kind.INLINE_FRAGMENT 
-            && (selection.typeCondition?.name.value === type.name)
-          ) as InlineFragmentNode|undefined
-        
-        if (!inlineFragment) {
-          inlineFragment = createInlineFragment(type, '__typename')
-          ;(selSet.selections as any[]).push(inlineFragment)
-        }
-        const fragmentStackItem = {type: type, selectionSet: inlineFragment.selectionSet!, parent: stackItem}
-        const appendFieldType = type.getFields()[fieldName!]?.type
-        if(!appendFieldType) {
-          if (fieldName === '__typename') {
-            passStackItems.push(fragmentStackItem)              
-          }
-          return
-        }
-        const newStackItem = processGraphqlObjectType(fragmentStackItem, appendFieldType, fieldName!)
-        passStackItems.push(newStackItem)              
-      })
-      return;
-    }
-    const parentObjectType = isObjectType(parentType) ? parentType : stackItem.parent?.type as GraphQLObjectType|undefined
-    if (!parentObjectType) return;
-    const field = parentObjectType.getFields()[fieldName!]
-    if(!field) {              
-      return
-    }        
-    const newStackItem = processGraphqlObjectType(stackItem, field.type, fieldName!)
-    passStackItems.push(newStackItem)  
-    
-  })
-  return passStackItems
-}
-
-
-
-function processGraphqlObjectType(stackItem: StackItem, fieldType: GraphQLOutputType, fieldName: string): StackItem {
-  const selSet = stackItem.selectionSet
-  if(!selSet){
-    throw new Error('Selection set not found')
-  }
-  const realFieldType = getNamedType(fieldType)
-  const subFieldsSelections = [isPrimitiveType(realFieldType) ? undefined : typeNameFieldNode].filter(Boolean) as FieldNode[]
-  let fieldNode = findFieldNode(selSet, fieldName)
-  if(!fieldNode) {
-    fieldNode = createFieldNode(fieldName, subFieldsSelections.map(selection => selection.name.value!))        
-    ;(selSet.selections as any[]).push(fieldNode)
-  }
-  return {type: realFieldType, selectionSet: fieldNode.selectionSet!, parent: stackItem}    
-}
-
-

package/src/utils/graphql/index.ts

@@ -1,51 +0,0 @@
-import { getNamedType, isScalarType, isEnumType, Kind } from "graphql"
-import type { GraphQLOutputType, SelectionSetNode, FieldNode, InlineFragmentNode, GraphQLNamedOutputType, SelectionNode } from "graphql"
-
-
-export function isPrimitiveType(type: GraphQLOutputType): boolean {
-  const namedType = getNamedType(type)
-  return isScalarType(namedType) || isEnumType(namedType)
-}
-
-export function findFieldNode(selectionSet: SelectionSetNode, fieldName: string):FieldNode|undefined {
-  return selectionSet?.selections.find(selection => selection.kind === Kind.FIELD && selection.name.value === fieldName) as FieldNode|undefined
-}
-
-
-export function createFieldNode(fieldName: string, children?: string[]):FieldNode {
-  let selectionSet: SelectionSetNode|undefined = undefined
-  if(children?.length) {
-    selectionSet = {
-      kind: Kind.SELECTION_SET,
-      selections: children.map(child => createFieldNode(child)),
-    } satisfies SelectionSetNode
-  }
-  return {
-    kind: Kind.FIELD,
-    name: { kind: Kind.NAME, value: fieldName },
-    selectionSet
-  }
-}      
-
-
-
-export function createFieldSelectionSet(outputType: GraphQLNamedOutputType, fieldName?: string):SelectionSetNode {
-  const ret = {
-    kind: Kind.SELECTION_SET,
-    selections: [fieldName ? createFieldNode(fieldName): undefined].filter(Boolean) as SelectionNode[],
-  } satisfies SelectionSetNode
-  
-  if (!isPrimitiveType(outputType) && !ret.selections.find(selection => selection.kind === Kind.FIELD && selection.name.value === '__typename')) {
-    ret.selections.unshift(createFieldNode('__typename'))
-  }
-  return ret
-}
-
-
-export function createInlineFragment(outputType: GraphQLNamedOutputType, fieldName: string):InlineFragmentNode {
-  return {
-    kind: Kind.INLINE_FRAGMENT,
-    typeCondition: { kind: Kind.NAMED_TYPE, name: { kind: Kind.NAME, value: outputType.name } },
-    selectionSet: createFieldSelectionSet(outputType, fieldName),
-  } satisfies InlineFragmentNode
-}

package/src/utils/jsonPath/guards.ts

@@ -1,37 +0,0 @@
-
-import type { BaseNode, IdentifierNode, ASTNode, NumericLiteralNode, FilterExpressionNode, ScriptExpressionNode, StringLiteralNode, WildcardNode, SliceNode, RootNode } from "./types"
-
-export function isAstNode(node: unknown): node is ASTNode {
-  return typeof node === 'object' && node !== null && 'expression' in node && typeof node.expression === 'object' && node.expression !== null && 'type' in node.expression && typeof node.expression.type === 'string'
-}
-export function isBaseNode(node: ASTNode): node is BaseNode {
-  return isAstNode(node) && 'operation' in node && typeof node.operation === 'string' && 'scope' in node && typeof node.scope === 'string'
-}
-export function isIdentifierNode(node: ASTNode): node is IdentifierNode {
-  return isBaseNode(node) && node.operation === 'member' && node.expression.type === 'identifier'
-}
-export function isNumericLiteralNode(node: ASTNode): node is NumericLiteralNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'numeric_literal'
-}
-export function isFilterExpressionNode(node: ASTNode): node is FilterExpressionNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'filter_expression'
-}
-export function isScriptExpressionNode(node: ASTNode): node is ScriptExpressionNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'script_expression'
-}
-export function isStringLiteralNode(node: ASTNode): node is StringLiteralNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'string_literal'
-}
-export function isWildcardNode(node: ASTNode): node is WildcardNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'wildcard'
-}
-export function isSliceNode(node: ASTNode): node is SliceNode {
-  return isBaseNode(node) && node.operation === 'subscript' && node.expression.type === 'slice'
-}
-export function isRootNode(node: ASTNode): node is RootNode {
-  return isAstNode(node) && node.expression.type === 'root' && node.expression.value === '$'
-}
-
-export function isJSONPath(nodes: unknown): nodes is ASTNode[] {
-  return Array.isArray(nodes) && nodes.every(node => isAstNode(node))
-}

package/src/utils/jsonPath/index.ts

@@ -1,3 +0,0 @@
-export * from './types'
-export * from './guards'
-export * from './visitor'

package/src/utils/jsonPath/types.ts

@@ -1,56 +0,0 @@
-export interface ASTNode {    
-    expression: Expression
-}
-
-export type ExpressionType = 'root' | 'identifier' | 'numeric_literal' | 'filter_expression' | 'script_expression' | 'string_literal' | 'wildcard' | 'slice'
-export type ExpressionValue = string | number | undefined
-
-interface BuildExpression<T extends ExpressionType = ExpressionType, V extends ExpressionValue = ExpressionValue> {
-  type: T
-  value: V
-}
-/** expression types */
-export type Expression = BuildExpression<ExpressionType, ExpressionValue>
-export type RootExpression = BuildExpression<'root', '$'>
-export type IdentifierExpression = BuildExpression<'identifier', string>
-export type NumericLiteralExpression = BuildExpression<'numeric_literal', number>
-export type FilterExpressionExpression = BuildExpression<'filter_expression', `?(${string})`>
-export type ScriptExpressionExpression = BuildExpression<'script_expression', string>
-export type StringLiteralExpression = BuildExpression<'string_literal', string>
-export type WildcardExpression = BuildExpression<'wildcard', '*'>
-export type SliceExpression = BuildExpression<'slice', `${number|''}:${number|''}`>
-
-/** node types */
-export interface RootNode extends ASTNode {
-  expression: RootExpression
-}
-export interface BaseNode<T extends 'member' | 'subscript' = 'member'|'subscript'> extends ASTNode {
-  operation: T
-  scope: 'child' | 'descendant' | 'parent'
-}
-export interface IdentifierNode extends BaseNode<'member'> {
-  expression: IdentifierExpression
-}
-export interface NumericLiteralNode extends BaseNode<'subscript'> {
-  expression: NumericLiteralExpression
-}
-export interface FilterExpressionNode extends BaseNode<'subscript'> {
-  expression: FilterExpressionExpression
-}
-export interface ScriptExpressionNode extends BaseNode<'subscript'> {
-  expression: ScriptExpressionExpression
-}
-export interface StringLiteralNode extends BaseNode<'subscript'> {
-  expression: StringLiteralExpression
-}
-export interface WildcardNode extends BaseNode<'subscript'> {
-  expression: WildcardExpression
-}
-export interface SliceNode extends BaseNode<'subscript'> {
-  expression: SliceExpression
-}
-
-
-
-
-

package/src/utils/jsonPath/visitor.ts

@@ -1,108 +0,0 @@
-import type { ASTNode, ExpressionType, RootNode, IdentifierNode, NumericLiteralNode, FilterExpressionNode, ScriptExpressionNode, StringLiteralNode, WildcardNode, SliceNode } from "./types"
-import { isJSONPath } from "./guards"
-import { isAstNode } from "./guards"
-import { snakeToPascalCase, type SnakeToPascalCase } from "~/utils/ts/helpers"
-
-export const BREAK = Symbol('BREAK')
-
-type Kind = {
-  root: RootNode
-  identifier: IdentifierNode
-  numeric_literal: NumericLiteralNode
-  filter_expression: FilterExpressionNode
-  script_expression: ScriptExpressionNode
-  string_literal: StringLiteralNode
-  wildcard: WildcardNode
-  slice: SliceNode
-}
-
-
-/** visitor types */
-export type VisitorFn = (node: ASTNode, parent: ASTNode|null, index: Array<number>, ancestors: ASTNode[]) => ASTNode|typeof BREAK|undefined|null|void
-export type TypedVisitorFn<T extends ExpressionType = ExpressionType> = (node: Kind[T], parent: ASTNode|null, index: Array<number>, ancestors: ASTNode[]) => ASTNode|typeof BREAK|undefined|null|void
-export interface IVisitor {
-  enter?:VisitorFn;
-  leave?:VisitorFn;
-}
-export type NodeVisitor = {
-  [T in ExpressionType as `${'leave' | ''}${SnakeToPascalCase<T>}`]?: TypedVisitorFn<T>;    
-} & IVisitor
-
-function doVisit(nodes: ASTNode[]|Array<ASTNode[]>, visitor: IVisitor):void {
-  if (isJSONPath(nodes)){
-    nodes = [nodes]
-  }        
-  for (const jsonPath of nodes) {      
-    let parent: ASTNode|null = null
-    let ancestors: ASTNode[] = []
-    let path: Array<number> = []
-    for (let i = 0; i < jsonPath.length; i++) {
-      const _node = jsonPath[i]!
-      let node: ASTNode = _node  
-      path.push(i)
-      const enterResult = visitor.enter?.(node, parent, path, ancestors)
-      if(enterResult === BREAK) {
-        break
-      }
-      if(isAstNode(enterResult)) {
-        node = enterResult
-      }
-      parent = node
-      ancestors.push(node)               
-      jsonPath[i] = node        
-    }      
-    parent = ancestors.pop() ?? null
-    path.pop()
-    for (let i = jsonPath.length - 1; i >= 0; i--) {
-      const _node = jsonPath[i]!
-      let node: ASTNode = _node
-      parent = ancestors.pop() ?? null        
-      path.pop()
-      const leaveResult = visitor.leave?.(node, parent, path, ancestors)
-      if(leaveResult === BREAK) {
-        break;
-      }
-      if(isAstNode(leaveResult)) {
-        node = leaveResult
-      }
-      jsonPath[i] = node        
-    }
-  }
-}
-
-
-function makeVisitor(visitor: NodeVisitor): IVisitor {
-  const visitorCall = function (type:'enter'|'leave', ...[node, ...rest]: Parameters<TypedVisitorFn>): ReturnType<TypedVisitorFn> {
-    let result: ReturnType<TypedVisitorFn>
-    //call leave node method
-    if (type === 'leave') {
-      const methodName = `${type}${snakeToPascalCase(node.expression.type) as SnakeToPascalCase<ExpressionType>}` as keyof NodeVisitor
-      result = visitor[methodName]?.(node as any,...rest)
-      if(result === BREAK) {
-        return result
-      }
-    }
-    //call original visitor
-    if (type in visitor) {
-      result = (visitor as IVisitor)[type as keyof IVisitor]?.(node, ...rest)
-      if(result === BREAK) {
-        return result
-      }
-    }      
-    //call enter enter node method
-    if (type === 'enter') {
-      const methodName = `${snakeToPascalCase(node.expression.type) as SnakeToPascalCase<ExpressionType>}` as keyof NodeVisitor
-      result = visitor[methodName]?.(node as any,...rest)
-    }
-    return result
-  }
-  const result: IVisitor = {
-    enter: visitorCall.bind(null, 'enter') as VisitorFn,
-    leave: visitorCall.bind(null, 'leave') as VisitorFn,
-  }
-  return result
-}
-
-export function visit(nodes: ASTNode[]|Array<ASTNode[]>, visitor: NodeVisitor):void{
-  doVisit(nodes, makeVisitor(visitor))
-}

package/src/utils/ts/helpers.ts

@@ -1,13 +0,0 @@
-export type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? 
-`${T}${Capitalize<SnakeToCamelCase<U>>}` :  S
-export type SnakeToPascalCase<S extends string> = Capitalize<SnakeToCamelCase<S>>
-
-
-export function snakeToCamelCase(str: string): SnakeToCamelCase<string> 
-{
-  return str.split('_').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('') as SnakeToCamelCase<string>
-}
-export function snakeToPascalCase(str: string): SnakeToPascalCase<string> 
-{
-  return snakeToCamelCase(str).charAt(0).toUpperCase() + snakeToCamelCase(str).slice(1) as SnakeToPascalCase<string>
-}