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

package/jest.config.ts

@@ -1,241 +0,0 @@
-/**
- * For a detailed explanation regarding each configuration property, visit:
- * https://jestjs.io/docs/configuration
- */
-
-const fs = require('node:fs')
-const { pathsToModuleNameMapper } = require('ts-jest')
-const JSON5 = require('json5')
-
-
-const jsonData = fs.readFileSync('./tsconfig.jest.json')
-const jscConfig = JSON5.parse(fs.readFileSync('./.swcrc').toString('utf-8'))
-const { compilerOptions } = JSON5.parse(jsonData.toString('utf-8'))
-
-const config = {
-  // All imported modules in your tests should be mocked automatically
-  // automock: false,
-
-  // Stop running tests after `n` failures
-  // bail: 0,
-
-  // The directory where Jest should store its cached dependency information
-  // cacheDirectory: "/tmp/jest_rs",
-
-  // Automatically clear mock calls, instances, contexts and results before every test
-  clearMocks: true,
-
-  // Indicates whether the coverage information should be collected while executing the test
-  collectCoverage: true,
-
-  // An array of glob patterns indicating a set of files for which coverage information should be collected
-  // collectCoverageFrom: undefined,
-
-  // The directory where Jest should output its coverage files
-  coverageDirectory: 'coverage',
-
-  // An array of regexp pattern strings used to skip coverage collection
-  coveragePathIgnorePatterns: [
-    "/node_modules/",
-
-  ],
-
-  // Indicates which provider should be used to instrument code for coverage
-  coverageProvider: 'v8',
-
-  // A list of reporter names that Jest uses when writing coverage reports
-  // coverageReporters: [
-  //   "json",
-  //   "text",
-  //   "lcov",
-  //   "clover"
-  // ],
-
-  // An object that configures minimum threshold enforcement for coverage results
-  // coverageThreshold: undefined,
-
-  // A path to a custom dependency extractor
-  // dependencyExtractor: undefined,
-
-  // Make calling deprecated APIs throw helpful error messages
-  // errorOnDeprecated: false,
-
-  // The default configuration for fake timers
-  // fakeTimers: {
-  //   "enableGlobally": false
-  // },
-
-  // Force coverage collection from ignored files using an array of glob patterns
-  // forceCoverageMatch: [],
-
-  // A path to a module which exports an async function that is triggered once before all test suites
-  // globalSetup: undefined,
-
-  // A path to a module which exports an async function that is triggered once after all test suites
-  // globalTeardown: undefined,
-
-  // A set of global variables that need to be available in all test environments
-  globals: {
-    
-  },
-  transform: {
-    // '^.+\\.tsx?$': ['ts-jest', { 
-    //   // babel: true,
-    //   tsconfig: 'tsconfig.jest.json',
-    // }],
-    '^.+\\.(t|j)sx?$': ['@swc/jest',
-      jscConfig
-    ]
-      
-},
-
-  testEnvironment: 'node',
-
-  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
-  // maxWorkers: "50%",
-
-  // An array of directory names to be searched recursively up from the requiring module's location
-  // moduleDirectories: [
-  //   "node_modules"
-  // ],
-
-  // An array of file extensions your modules use
-  // moduleFileExtensions: [
-  //   "js",
-  //   "mjs",
-  //   "cjs",
-  //   "jsx",
-  //   "ts",
-  //   "tsx",
-  //   "json",
-  //   "node"
-  // ],
-
-  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
-  moduleNameMapper: {
-    ...pathsToModuleNameMapper(compilerOptions.paths, { prefix: '<rootDir>/' }),
-    '^~/(.*)$': '<rootDir>/src/$1',
-  },
-
-  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
-  // modulePathIgnorePatterns: [],
-
-  // Activates notifications for test results
-  notify: true,
-
-  // An enum that specifies notification mode. Requires { notify: true }
-  notifyMode: 'failure',
-
-  // A preset that is used as a base for Jest's configuration
-  preset: 'ts-jest',
-
-  // Run tests from one or more projects
-  // projects: undefined,
-
-  // Use this configuration option to add custom reporters to Jest
-  // reporters: undefined,
-  reporters: [
-    'default',
-    [
-      '@jest-performance-reporter/core',
-      {
-        errorAfterMs: 1000,
-        warnAfterMs: 50,
-        logLevel: 'warn',
-        maxItems: 1,
-        // "jsonReportPath": "performance-report.json",
-        // "csvReportPath": "performance-report.csv"
-      },
-    ],
-  ],
-
-  // Automatically reset mock state before every test
-  // resetMocks: false,
-
-  // Reset the module registry before running each individual test
-  // resetModules: false,
-
-  // A path to a custom resolver
-  // resolver: undefined,
-
-  // Automatically restore mock state and implementation before every test
-  // restoreMocks: false,
-
-  // The root directory that Jest should scan for tests and modules within
-  rootDir: './',
-
-  // A list of paths to directories that Jest should use to search for files in
-  // roots: [
-  //   "<rootDir>"
-  // ],
-
-  // Allows you to use a custom runner instead of Jest's default test runner
-  // runner: "jest-runner",
-
-  // The paths to modules that run some code to configure or set up the testing environment before each test
-  setupFiles: [
-    "./register.setup.jest.ts"
-  ],
-
-  // A list of paths to modules that run some code to configure or set up the testing framework before each test
-  // setupFilesAfterEnv: [],
-
-  // The number of seconds after which a test is considered as slow and reported as such in the results.
-  // slowTestThreshold: 5,
-
-  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
-  // snapshotSerializers: [],
-
-  // The test environment that will be used for testing
-  // testEnvironment: "jest-environment-node",
-
-  // Options that will be passed to the testEnvironment
-  // testEnvironmentOptions: {},
-
-  // Adds a location field to test results
-  // testLocationInResults: false,
-
-  // The glob patterns Jest uses to detect test files
-  testMatch: [
-    "**/src/**/__tests__/**/*.[jt]s?(x)",
-    "**/src/**/?(*.)+(spec|test).[tj]s?(x)"
-  ],
-
-  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
-  testPathIgnorePatterns: [
-    '/node_modules/',
-    '/dist/',
-  ],
-
-  // The regexp pattern or array of patterns that Jest uses to detect test files
-  // testRegex: [],
-
-  // This option allows the use of a custom results processor
-  // testResultsProcessor: undefined,
-
-  // This option allows use of a custom test runner
-  // testRunner: "jest-circus/runner",
-
-  // A map from regular expressions to paths to transformers
-  // transform: undefined,
-
-  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
-  transformIgnorePatterns: [
-    '/node_modules/',
-    '\\.pnp\\.[^\\/]+$',
-  ],
-
-  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
-  // unmockedModulePathPatterns: undefined,
-
-  // Indicates whether each individual test should be reported during the run
-  // verbose: undefined,
-
-  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
-  // watchPathIgnorePatterns: [],
-
-  // Whether to use watchman for file crawling
-  // watchman: true,
-}
-
-module.exports = config

package/nodemon.json

@@ -1,27 +0,0 @@
-{
-  "verbose": false,
-  "ignore": [
-    ".git",
-    "node_modules",
-    "./.*",
-    "./var/**/*",
-    "./docker-compose/**"
-  ],
-  "watch": [
-    "**/*"
-  ],
-  "ext": "js ts gql",
-  "signal": "SIGQUIT",
-  "execMap": {
-    "ts": "NODE_ENV=${NODE_ENV:-development} NODE_OPTIONS='--max-http-header-size=65535' UWS_HTTP_MAX_HEADERS_SIZE=65535 tsx   --trace-warnings --trace-uncaught"
-
-  },
-  "spawn": false,
-  "delay": "200",
-  "legacyWatch": false,
-
-  "events": {
-    
-  }
-
-}

package/register.setup.jest.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=register.setup.jest.d.ts.map

package/register.setup.jest.ts

@@ -1,19 +0,0 @@
-
-// import {jest} from '@jest/globals'
-
-import path from 'path'
-
-
-
-
-import glob from 'fast-glob'
-// jest.mock('~/config/AWS')
-
-
-
-
-
-glob.sync('src/**/__mock__/**/*.ts', {cwd: process.cwd()}).forEach(file => {
-  require(path.join(process.cwd(), file))
-})
-

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from '~/parser/parseJsonPaths'
-

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
-}
-
-
-
-
-