Function parseQuery

src/babel/parse-query.ts:79–135

(path: NodePath<types.TemplateLiteral>, sourceFile: SourceFile)

}

export function parseQuery(path: NodePath<types.TemplateLiteral>, sourceFile: SourceFile): Query {
  const expressions = path.get("expressions")
  const textPartials = path.get("quasis").map(quasi => quasi.node)

  const expressionSpreadTypes: ExpressionSpreadTypes = {}
  const sourceMap: QuerySourceMapSpan[] = []
  let templatedQueryString: string = ""

  const addToQueryString = (
    node: types.Node,
    queryStringPartial: string,
    isTemplateExpression?: boolean
  ) => {
    if (node.loc) {
      sourceMap.push({
        isTemplateExpression,
        sourceLocation: node.loc,
        queryStartIndex: templatedQueryString.length,
        queryEndIndex: templatedQueryString.length + queryStringPartial.length
      })
    }

    return templatedQueryString + queryStringPartial
  }

  templatedQueryString = addToQueryString(textPartials[0], textPartials[0].value.cooked)

  for (let index = 0; index < expressions.length; index++) {
    const expression = expressions[index]
    const paramNumber = index + 1

    const placeholder = createExpressionPlaceholder(expression, paramNumber)
    templatedQueryString = addToQueryString(expression.node, placeholder, true)

    expressionSpreadTypes[paramNumber] = resolveSpreadExpressionType(expression, sourceFile)

    if (expressionSpreadTypes[paramNumber] === spreadTypeAny && sourceFile.ts) {
      const lineHint = path.node.loc ? `:${path.node.loc.start.line}` : ``
      console.warn(
        format.warning(
          `Warning: Cannot infer properties of spread expression in SQL template at ${
            sourceFile.filePath
          }${lineHint}`
        )
      )
    }

    if (textPartials[index + 1]) {
      templatedQueryString = addToQueryString(
        textPartials[index + 1],
        textPartials[index + 1].value.cooked
      )
    }
  }

  return parsePostgresQuery(templatedQueryString, sourceFile, sourceMap, expressionSpreadTypes)
}