chore(types): make types retrocompatible to typescript 4.5.5

package.json

@@ -60,7 +60,7 @@
     "ts-jest": "^28.0.3",
     "tsd": "^0.31.2",
     "typedoc": "^0.22.16",
-    "typescript": "~4.7",
+    "typescript": "4.5.5",
     "wait-for-localhost-cli": "^3.0.0"
   }
 }

src/select-query-parser/parser.ts

@@ -12,10 +12,12 @@ import { SimplifyDeep } from '../types'
  */
 export type ParseQuery<Query extends string> = string extends Query
   ? GenericStringError
-  : ParseNodes<EatWhitespace<Query>> extends [infer Nodes extends Ast.Node[], `${infer Remainder}`]
-  ? EatWhitespace<Remainder> extends ''
-    ? SimplifyDeep<Nodes>
-    : ParserError<`Unexpected input: ${Remainder}`>
+  : ParseNodes<EatWhitespace<Query>> extends [infer Nodes, `${infer Remainder}`]
+  ? Nodes extends Ast.Node[]
+    ? EatWhitespace<Remainder> extends ''
+      ? SimplifyDeep<Nodes>
+      : ParserError<`Unexpected input: ${Remainder}`>
+    : ParserError<'Invalid nodes array structure'>
   : ParseNodes<EatWhitespace<Query>>
 
 /**
@@ -34,14 +36,15 @@ type ParseNodes<Input extends string> = string extends Input
   : ParseNodesHelper<Input, []>
 
 type ParseNodesHelper<Input extends string, Nodes extends Ast.Node[]> = ParseNode<Input> extends [
-  infer Node extends Ast.Node,
+  infer Node,
   `${infer Remainder}`
 ]
-  ? EatWhitespace<Remainder> extends `,${infer Remainder}`
-    ? ParseNodesHelper<EatWhitespace<Remainder>, [...Nodes, Node]>
-    : [[...Nodes, Node], EatWhitespace<Remainder>]
+  ? Node extends Ast.Node
+    ? EatWhitespace<Remainder> extends `,${infer Remainder}`
+      ? ParseNodesHelper<EatWhitespace<Remainder>, [...Nodes, Node]>
+      : [[...Nodes, Node], EatWhitespace<Remainder>]
+    : ParserError<'Invalid node type in nodes helper'>
   : ParseNode<Input>
-
 /**
  * Parses a node.
  * A node is one of the following:
@@ -57,23 +60,21 @@ type ParseNode<Input extends string> = Input extends ''
   ? [Ast.StarNode, EatWhitespace<Remainder>]
   : // `...field`
   Input extends `...${infer Remainder}`
-  ? ParseField<EatWhitespace<Remainder>> extends [
-      infer TargetField extends Ast.FieldNode,
-      `${infer Remainder}`
-    ]
-    ? [{ type: 'spread'; target: TargetField }, EatWhitespace<Remainder>]
+  ? ParseField<EatWhitespace<Remainder>> extends [infer TargetField, `${infer Remainder}`]
+    ? TargetField extends Ast.FieldNode
+      ? [{ type: 'spread'; target: TargetField }, EatWhitespace<Remainder>]
+      : ParserError<'Invalid target field type in spread'>
     : ParserError<`Unable to parse spread resource at \`${Input}\``>
   : ParseIdentifier<Input> extends [infer NameOrAlias, `${infer Remainder}`]
   ? EatWhitespace<Remainder> extends `::${infer _}`
     ? // It's a type cast and not an alias, so treat it as part of the field.
       ParseField<Input>
     : EatWhitespace<Remainder> extends `:${infer Remainder}`
     ? // `alias:`
-      ParseField<EatWhitespace<Remainder>> extends [
-        infer Field extends Ast.FieldNode,
-        `${infer Remainder}`
-      ]
-      ? [Omit<Field, 'alias'> & { alias: NameOrAlias }, EatWhitespace<Remainder>]
+      ParseField<EatWhitespace<Remainder>> extends [infer Field, `${infer Remainder}`]
+      ? Field extends Ast.FieldNode
+        ? [Omit<Field, 'alias'> & { alias: NameOrAlias }, EatWhitespace<Remainder>]
+        : ParserError<'Invalid field type in alias parsing'>
       : ParserError<`Unable to parse renamed field at \`${Input}\``>
     : // Otherwise, just parse it as a field without alias.
       ParseField<Input>
@@ -98,24 +99,22 @@ type ParseField<Input extends string> = Input extends ''
   ? Name extends 'count'
     ? ParseCountField<Input>
     : Remainder extends `!inner${infer Remainder}`
-    ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-        infer Children extends Ast.Node[],
-        `${infer Remainder}`
-      ]
-      ? // `field!inner(nodes)`
-        [{ type: 'field'; name: Name; innerJoin: true; children: Children }, Remainder]
+    ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [infer Children, `${infer Remainder}`]
+      ? Children extends Ast.Node[]
+        ? // `field!inner(nodes)`
+          [{ type: 'field'; name: Name; innerJoin: true; children: Children }, Remainder]
+        : ParserError<'Invalid children array in inner join'>
       : CreateParserErrorIfRequired<
           ParseEmbeddedResource<EatWhitespace<Remainder>>,
           `Expected embedded resource after "!inner" at \`${Remainder}\``
         >
     : EatWhitespace<Remainder> extends `!left${infer Remainder}`
-    ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-        infer Children extends Ast.Node[],
-        `${infer Remainder}`
-      ]
-      ? // `field!left(nodes)`
-        // !left is a noise word - treat it the same way as a non-`!inner`.
-        [{ type: 'field'; name: Name; children: Children }, EatWhitespace<Remainder>]
+    ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [infer Children, `${infer Remainder}`]
+      ? Children extends Ast.Node[]
+        ? // `field!left(nodes)`
+          // !left is a noise word - treat it the same way as a non-`!inner`.
+          [{ type: 'field'; name: Name; children: Children }, EatWhitespace<Remainder>]
+        : ParserError<'Invalid children array in left join'>
       : CreateParserErrorIfRequired<
           ParseEmbeddedResource<EatWhitespace<Remainder>>,
           `Expected embedded resource after "!left" at \`${EatWhitespace<Remainder>}\``
@@ -124,30 +123,36 @@ type ParseField<Input extends string> = Input extends ''
     ? ParseIdentifier<EatWhitespace<Remainder>> extends [infer Hint, `${infer Remainder}`]
       ? EatWhitespace<Remainder> extends `!inner${infer Remainder}`
         ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-            infer Children extends Ast.Node[],
+            infer Children,
             `${infer Remainder}`
           ]
-          ? // `field!hint!inner(nodes)`
-            [
-              { type: 'field'; name: Name; hint: Hint; innerJoin: true; children: Children },
-              EatWhitespace<Remainder>
-            ]
+          ? Children extends Ast.Node[]
+            ? // `field!hint!inner(nodes)`
+              [
+                { type: 'field'; name: Name; hint: Hint; innerJoin: true; children: Children },
+                EatWhitespace<Remainder>
+              ]
+            : ParserError<'Invalid children array in hint inner join'>
           : ParseEmbeddedResource<EatWhitespace<Remainder>>
         : ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-            infer Children extends Ast.Node[],
+            infer Children,
             `${infer Remainder}`
           ]
-        ? // `field!hint(nodes)`
-          [{ type: 'field'; name: Name; hint: Hint; children: Children }, EatWhitespace<Remainder>]
+        ? Children extends Ast.Node[]
+          ? // `field!hint(nodes)`
+            [
+              { type: 'field'; name: Name; hint: Hint; children: Children },
+              EatWhitespace<Remainder>
+            ]
+          : ParserError<'Invalid children array in hint'>
         : ParseEmbeddedResource<EatWhitespace<Remainder>>
       : ParserError<`Expected identifier after "!" at \`${EatWhitespace<Remainder>}\``>
     : EatWhitespace<Remainder> extends `(${infer _}`
-    ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
-        infer Children extends Ast.Node[],
-        `${infer Remainder}`
-      ]
-      ? // `field(nodes)`
-        [{ type: 'field'; name: Name; children: Children }, EatWhitespace<Remainder>]
+    ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [infer Children, `${infer Remainder}`]
+      ? Children extends Ast.Node[]
+        ? // `field(nodes)`
+          [{ type: 'field'; name: Name; children: Children }, EatWhitespace<Remainder>]
+        : ParserError<'Invalid children array in field'>
       : // Return error if start of embedded resource was detected but not found.
         ParseEmbeddedResource<EatWhitespace<Remainder>>
     : // Otherwise it's a non-embedded resource field.
@@ -184,13 +189,12 @@ type ParseCountField<Input extends string> = ParseIdentifier<Input> extends [
 type ParseEmbeddedResource<Input extends string> = Input extends `(${infer Remainder}`
   ? EatWhitespace<Remainder> extends `)${infer Remainder}`
     ? [[], EatWhitespace<Remainder>]
-    : ParseNodes<EatWhitespace<Remainder>> extends [
-        infer Nodes extends Ast.Node[],
-        `${infer Remainder}`
-      ]
-    ? EatWhitespace<Remainder> extends `)${infer Remainder}`
-      ? [Nodes, EatWhitespace<Remainder>]
-      : ParserError<`Expected ")" at \`${EatWhitespace<Remainder>}\``>
+    : ParseNodes<EatWhitespace<Remainder>> extends [infer Nodes, `${infer Remainder}`]
+    ? Nodes extends Ast.Node[]
+      ? EatWhitespace<Remainder> extends `)${infer Remainder}`
+        ? [Nodes, EatWhitespace<Remainder>]
+        : ParserError<`Expected ")" at \`${EatWhitespace<Remainder>}\``>
+      : ParserError<'Invalid nodes array in embedded resource'>
     : ParseNodes<EatWhitespace<Remainder>>
   : ParserError<`Expected "(" at \`${Input}\``>
 

src/select-query-parser/result.ts

@@ -35,14 +35,18 @@ export type GetResult<
   Relationships,
   Query extends string
 > = IsAny<Schema> extends true
-  ? ParseQuery<Query> extends infer ParsedQuery extends Ast.Node[]
-    ? RelationName extends string
-      ? ProcessNodesWithoutSchema<ParsedQuery>
-      : any
+  ? ParseQuery<Query> extends infer ParsedQuery
+    ? ParsedQuery extends Ast.Node[]
+      ? RelationName extends string
+        ? ProcessNodesWithoutSchema<ParsedQuery>
+        : any
+      : ParsedQuery
     : any
   : Relationships extends null // For .rpc calls the passed relationships will be null in that case, the result will always be the function return type
-  ? ParseQuery<Query> extends infer ParsedQuery extends Ast.Node[]
-    ? RPCCallNodes<ParsedQuery, RelationName extends string ? RelationName : 'rpc_call', Row>
+  ? ParseQuery<Query> extends infer ParsedQuery
+    ? ParsedQuery extends Ast.Node[]
+      ? RPCCallNodes<ParsedQuery, RelationName extends string ? RelationName : 'rpc_call', Row>
+      : ParsedQuery
     : Row
   : ParseQuery<Query> extends infer ParsedQuery
   ? ParsedQuery extends Ast.Node[]
@@ -111,11 +115,15 @@ type ProcessNodeWithoutSchema<Node extends Ast.Node> = Node extends Ast.StarNode
 type ProcessNodesWithoutSchema<
   Nodes extends Ast.Node[],
   Acc extends Record<string, unknown> = {}
-> = Nodes extends [infer FirstNode extends Ast.Node, ...infer RestNodes extends Ast.Node[]]
-  ? ProcessNodeWithoutSchema<FirstNode> extends infer FieldResult
-    ? FieldResult extends Record<string, unknown>
-      ? ProcessNodesWithoutSchema<RestNodes, Acc & FieldResult>
-      : FieldResult
+> = Nodes extends [infer FirstNode, ...infer RestNodes]
+  ? FirstNode extends Ast.Node
+    ? RestNodes extends Ast.Node[]
+      ? ProcessNodeWithoutSchema<FirstNode> extends infer FieldResult
+        ? FieldResult extends Record<string, unknown>
+          ? ProcessNodesWithoutSchema<RestNodes, Acc & FieldResult>
+          : FieldResult
+        : any
+      : any
     : any
   : Prettify<Acc>
 
@@ -130,11 +138,11 @@ export type ProcessRPCNode<
   Row extends Record<string, unknown>,
   RelationName extends string,
   NodeType extends Ast.Node
-> = NodeType extends Ast.StarNode // If the selection is *
+> = NodeType['type'] extends Ast.StarNode['type'] // If the selection is *
   ? Row
-  : NodeType extends Ast.FieldNode
-  ? ProcessSimpleField<Row, RelationName, NodeType>
-  : SelectQueryError<'Unsupported node type.'>
+  : NodeType['type'] extends Ast.FieldNode['type']
+  ? ProcessSimpleField<Row, RelationName, Extract<NodeType, Ast.FieldNode>>
+  : SelectQueryError<'RPC Unsupported node type.'>
 /**
  * Process select call that can be chained after an rpc call
  */
@@ -143,14 +151,18 @@ export type RPCCallNodes<
   RelationName extends string,
   Row extends Record<string, unknown>,
   Acc extends Record<string, unknown> = {} // Acc is now an object
-> = Nodes extends [infer FirstNode extends Ast.Node, ...infer RestNodes extends Ast.Node[]]
-  ? ProcessRPCNode<Row, RelationName, FirstNode> extends infer FieldResult
-    ? FieldResult extends Record<string, unknown>
-      ? RPCCallNodes<RestNodes, RelationName, Row, Acc & FieldResult>
-      : FieldResult extends SelectQueryError<infer E>
-      ? SelectQueryError<E>
-      : SelectQueryError<'Could not retrieve a valid record or error value'>
-    : SelectQueryError<'Processing node failed.'>
+> = Nodes extends [infer FirstNode, ...infer RestNodes]
+  ? FirstNode extends Ast.Node
+    ? RestNodes extends Ast.Node[]
+      ? ProcessRPCNode<Row, RelationName, FirstNode> extends infer FieldResult
+        ? FieldResult extends Record<string, unknown>
+          ? RPCCallNodes<RestNodes, RelationName, Row, Acc & FieldResult>
+          : FieldResult extends SelectQueryError<infer E>
+          ? SelectQueryError<E>
+          : SelectQueryError<'Could not retrieve a valid record or error value'>
+        : SelectQueryError<'Processing node failed.'>
+      : SelectQueryError<'Invalid rest nodes array in RPC call'>
+    : SelectQueryError<'Invalid first node in RPC call'>
   : Prettify<Acc>
 
 /**
@@ -171,14 +183,18 @@ export type ProcessNodes<
   Nodes extends Ast.Node[],
   Acc extends Record<string, unknown> = {} // Acc is now an object
 > = CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes> extends false
-  ? Nodes extends [infer FirstNode extends Ast.Node, ...infer RestNodes extends Ast.Node[]]
-    ? ProcessNode<Schema, Row, RelationName, Relationships, FirstNode> extends infer FieldResult
-      ? FieldResult extends Record<string, unknown>
-        ? ProcessNodes<Schema, Row, RelationName, Relationships, RestNodes, Acc & FieldResult>
-        : FieldResult extends SelectQueryError<infer E>
-        ? SelectQueryError<E>
-        : SelectQueryError<'Could not retrieve a valid record or error value'>
-      : SelectQueryError<'Processing node failed.'>
+  ? Nodes extends [infer FirstNode, ...infer RestNodes]
+    ? FirstNode extends Ast.Node
+      ? RestNodes extends Ast.Node[]
+        ? ProcessNode<Schema, Row, RelationName, Relationships, FirstNode> extends infer FieldResult
+          ? FieldResult extends Record<string, unknown>
+            ? ProcessNodes<Schema, Row, RelationName, Relationships, RestNodes, Acc & FieldResult>
+            : FieldResult extends SelectQueryError<infer E>
+            ? SelectQueryError<E>
+            : SelectQueryError<'Could not retrieve a valid record or error value'>
+          : SelectQueryError<'Processing node failed.'>
+        : SelectQueryError<'Invalid rest nodes array type in ProcessNodes'>
+      : SelectQueryError<'Invalid first node type in ProcessNodes'>
     : Prettify<Acc>
   : Prettify<CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes>>
 
@@ -197,13 +213,15 @@ export type ProcessNode<
   RelationName extends string,
   Relationships extends GenericRelationship[],
   NodeType extends Ast.Node
-> = NodeType extends Ast.StarNode // If the selection is *
-  ? Row
-  : NodeType extends Ast.SpreadNode // If the selection is a ...spread
-  ? ProcessSpreadNode<Schema, Row, RelationName, Relationships, NodeType>
-  : NodeType extends Ast.FieldNode
-  ? ProcessFieldNode<Schema, Row, RelationName, Relationships, NodeType>
-  : SelectQueryError<'Unsupported node type.'>
+> =
+  // TODO: figure out why comparing the `type` property is necessary vs. `NodeType extends Ast.StarNode`
+  NodeType['type'] extends Ast.StarNode['type'] // If the selection is *
+    ? Row
+    : NodeType['type'] extends Ast.SpreadNode['type'] // If the selection is a ...spread
+    ? ProcessSpreadNode<Schema, Row, RelationName, Relationships, Extract<NodeType, Ast.SpreadNode>>
+    : NodeType['type'] extends Ast.FieldNode['type']
+    ? ProcessFieldNode<Schema, Row, RelationName, Relationships, Extract<NodeType, Ast.FieldNode>>
+    : SelectQueryError<'Unsupported node type.'>
 
 /**
  * Processes a FieldNode and returns the resulting TypeScript type.
@@ -369,7 +387,12 @@ type ProcessSpreadNode<
 /**
  * Helper type to process the result of a spread node.
  */
-type ProcessSpreadNodeResult<Result> = ExtractFirstProperty<Result> extends infer SpreadedObject
+type ProcessSpreadNodeResult<Result> = Result extends Record<
+  string,
+  SelectQueryError<string> | null
+>
+  ? Result
+  : ExtractFirstProperty<Result> extends infer SpreadedObject
   ? ContainsNull<SpreadedObject> extends true
     ? Exclude<{ [K in keyof SpreadedObject]: SpreadedObject[K] | null }, null>
     : Exclude<{ [K in keyof SpreadedObject]: SpreadedObject[K] }, null>