@supabase/postgrest-js 1.17.1 → 1.17.3

package/src/select-query-parser/utils.ts

@@ -38,27 +38,24 @@ type ResolveRelationships<
   Relationships extends GenericRelationship[],
   Nodes extends Ast.FieldNode[]
 > = UnionToArray<{
-  [K in keyof Nodes]: ResolveRelationship<
-    Schema,
-    Relationships,
-    Nodes[K],
-    RelationName
-  > extends infer Relation
-    ? Relation extends {
-        relation: {
-          referencedRelation: any
-          foreignKeyName: any
-          match: any
-        }
-        from: any
-      }
-      ? {
-          referencedTable: Relation['relation']['referencedRelation']
-          fkName: Relation['relation']['foreignKeyName']
-          from: Relation['from']
-          match: Relation['relation']['match']
-          fieldName: GetFieldNodeResultName<Nodes[K]>
+  [K in keyof Nodes]: Nodes[K] extends Ast.FieldNode
+    ? ResolveRelationship<Schema, Relationships, Nodes[K], RelationName> extends infer Relation
+      ? Relation extends {
+          relation: {
+            referencedRelation: string
+            foreignKeyName: string
+            match: string
+          }
+          from: string
         }
+        ? {
+            referencedTable: Relation['relation']['referencedRelation']
+            fkName: Relation['relation']['foreignKeyName']
+            from: Relation['from']
+            match: Relation['relation']['match']
+            fieldName: GetFieldNodeResultName<Nodes[K]>
+          }
+        : Relation
       : never
     : never
 }>[0]
@@ -69,10 +66,12 @@ type ResolveRelationships<
 type IsDoubleReference<T, U> = T extends {
   referencedTable: infer RT
   fieldName: infer FN
-  match: infer M extends 'col' | 'refrel'
+  match: infer M
 }
-  ? U extends { referencedTable: RT; fieldName: FN; match: M }
-    ? true
+  ? M extends 'col' | 'refrel'
+    ? U extends { referencedTable: RT; fieldName: FN; match: M }
+      ? true
+      : false
     : false
   : false
 
@@ -97,21 +96,25 @@ export type CheckDuplicateEmbededReference<
   RelationName extends string,
   Relationships extends GenericRelationship[],
   Nodes extends Ast.Node[]
-> = FilterRelationNodes<Nodes> extends infer RelationsNodes extends Ast.FieldNode[]
-  ? ResolveRelationships<
-      Schema,
-      RelationName,
-      Relationships,
-      RelationsNodes
-    > extends infer ResolvedRels
-    ? ResolvedRels extends unknown[]
-      ? FindDuplicates<ResolvedRels> extends infer Duplicates
-        ? Duplicates extends never
-          ? false
-          : Duplicates extends { fieldName: infer FieldName extends string }
-          ? {
-              [K in FieldName]: SelectQueryError<`table "${RelationName}" specified more than once use hinting for desambiguation`>
-            }
+> = FilterRelationNodes<Nodes> extends infer RelationsNodes
+  ? RelationsNodes extends Ast.FieldNode[]
+    ? ResolveRelationships<
+        Schema,
+        RelationName,
+        Relationships,
+        RelationsNodes
+      > extends infer ResolvedRels
+      ? ResolvedRels extends unknown[]
+        ? FindDuplicates<ResolvedRels> extends infer Duplicates
+          ? Duplicates extends never
+            ? false
+            : Duplicates extends { fieldName: infer FieldName }
+            ? FieldName extends string
+              ? {
+                  [K in FieldName]: SelectQueryError<`table "${RelationName}" specified more than once use hinting for desambiguation`>
+                }
+              : false
+            : false
           : false
         : false
       : false
@@ -155,33 +158,38 @@ type CheckRelationshipError<
   : // If the relation is a reverse relation with no hint (matching by name)
   FoundRelation extends {
       relation: {
-        referencedRelation: infer RelatedRelationName extends string
+        referencedRelation: infer RelatedRelationName
         name: string
       }
       direction: 'reverse'
     }
-  ? // We check if there is possible confusion with other relations with this table
-    HasMultipleFKeysToFRel<RelatedRelationName, Relationships> extends true
-    ? // If there is, postgrest will fail at runtime, and require desambiguation via hinting
-      SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`>
-    : FoundRelation
+  ? RelatedRelationName extends string
+    ? // We check if there is possible confusion with other relations with this table
+      HasMultipleFKeysToFRel<RelatedRelationName, Relationships> extends true
+      ? // If there is, postgrest will fail at runtime, and require desambiguation via hinting
+        SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`>
+      : FoundRelation
+    : never
   : // Same check for forward relationships, but we must gather the relationships from the found relation
   FoundRelation extends {
       relation: {
-        referencedRelation: infer RelatedRelationName extends string
+        referencedRelation: infer RelatedRelationName
         name: string
       }
       direction: 'forward'
-      from: infer From extends keyof TablesAndViews<Schema> & string
+      from: infer From
     }
-  ? HasMultipleFKeysToFRel<
-      RelatedRelationName,
-      TablesAndViews<Schema>[From]['Relationships']
-    > extends true
-    ? SelectQueryError<`Could not embed because more than one relationship was found for '${From}' and '${RelatedRelationName}' you need to hint the column with ${From}!<columnName> ?`>
-    : FoundRelation
+  ? RelatedRelationName extends string
+    ? From extends keyof TablesAndViews<Schema> & string
+      ? HasMultipleFKeysToFRel<
+          RelatedRelationName,
+          TablesAndViews<Schema>[From]['Relationships']
+        > extends true
+        ? SelectQueryError<`Could not embed because more than one relationship was found for '${From}' and '${RelatedRelationName}' you need to hint the column with ${From}!<columnName> ?`>
+        : FoundRelation
+      : never
+    : never
   : FoundRelation
-
 /**
  * Resolves relationships for embedded resources and retrieves the referenced Table
  */
@@ -217,26 +225,28 @@ type ResolveReverseRelationship<
 > = FindFieldMatchingRelationships<Schema, Relationships, Field> extends infer FoundRelation
   ? FoundRelation extends never
     ? false
-    : FoundRelation extends { referencedRelation: infer RelatedRelationName extends string }
-    ? RelatedRelationName extends keyof TablesAndViews<Schema>
-      ? // If the relation was found via hinting we just return it without any more checks
-        FoundRelation extends { hint: string }
-        ? {
-            referencedTable: TablesAndViews<Schema>[RelatedRelationName]
-            relation: FoundRelation
-            direction: 'reverse'
-            from: CurrentTableOrView
-          }
-        : // If the relation was found via implicit relation naming, we must ensure there is no conflicting matches
-        HasMultipleFKeysToFRel<RelatedRelationName, Relationships> extends true
-        ? SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`>
-        : {
-            referencedTable: TablesAndViews<Schema>[RelatedRelationName]
-            relation: FoundRelation
-            direction: 'reverse'
-            from: CurrentTableOrView
-          }
-      : SelectQueryError<`Relation '${RelatedRelationName}' not found in schema.`>
+    : FoundRelation extends { referencedRelation: infer RelatedRelationName }
+    ? RelatedRelationName extends string
+      ? RelatedRelationName extends keyof TablesAndViews<Schema>
+        ? // If the relation was found via hinting we just return it without any more checks
+          FoundRelation extends { hint: string }
+          ? {
+              referencedTable: TablesAndViews<Schema>[RelatedRelationName]
+              relation: FoundRelation
+              direction: 'reverse'
+              from: CurrentTableOrView
+            }
+          : // If the relation was found via implicit relation naming, we must ensure there is no conflicting matches
+          HasMultipleFKeysToFRel<RelatedRelationName, Relationships> extends true
+          ? SelectQueryError<`Could not embed because more than one relationship was found for '${RelatedRelationName}' and '${CurrentTableOrView}' you need to hint the column with ${RelatedRelationName}!<columnName> ?`>
+          : {
+              referencedTable: TablesAndViews<Schema>[RelatedRelationName]
+              relation: FoundRelation
+              direction: 'reverse'
+              from: CurrentTableOrView
+            }
+        : SelectQueryError<`Relation '${RelatedRelationName}' not found in schema.`>
+      : false
     : false
   : false
 
@@ -244,17 +254,19 @@ export type FindMatchingTableRelationships<
   Schema extends GenericSchema,
   Relationships extends GenericRelationship[],
   value extends string
-> = Relationships extends [infer R, ...infer Rest extends GenericRelationship[]]
-  ? R extends { referencedRelation: infer ReferencedRelation }
-    ? ReferencedRelation extends keyof Schema['Tables']
-      ? R extends { foreignKeyName: value }
-        ? R & { match: 'fkname' }
-        : R extends { referencedRelation: value }
-        ? R & { match: 'refrel' }
-        : R extends { columns: [value] }
-        ? R & { match: 'col' }
+> = Relationships extends [infer R, ...infer Rest]
+  ? Rest extends GenericRelationship[]
+    ? R extends { referencedRelation: infer ReferencedRelation }
+      ? ReferencedRelation extends keyof Schema['Tables']
+        ? R extends { foreignKeyName: value }
+          ? R & { match: 'fkname' }
+          : R extends { referencedRelation: value }
+          ? R & { match: 'refrel' }
+          : R extends { columns: [value] }
+          ? R & { match: 'col' }
+          : FindMatchingTableRelationships<Schema, Rest, value>
         : FindMatchingTableRelationships<Schema, Rest, value>
-      : FindMatchingTableRelationships<Schema, Rest, value>
+      : false
     : false
   : false
 
@@ -262,17 +274,19 @@ export type FindMatchingViewRelationships<
   Schema extends GenericSchema,
   Relationships extends GenericRelationship[],
   value extends string
-> = Relationships extends [infer R, ...infer Rest extends GenericRelationship[]]
-  ? R extends { referencedRelation: infer ReferencedRelation }
-    ? ReferencedRelation extends keyof Schema['Views']
-      ? R extends { foreignKeyName: value }
-        ? R & { match: 'fkname' }
-        : R extends { referencedRelation: value }
-        ? R & { match: 'refrel' }
-        : R extends { columns: [value] }
-        ? R & { match: 'col' }
+> = Relationships extends [infer R, ...infer Rest]
+  ? Rest extends GenericRelationship[]
+    ? R extends { referencedRelation: infer ReferencedRelation }
+      ? ReferencedRelation extends keyof Schema['Views']
+        ? R extends { foreignKeyName: value }
+          ? R & { match: 'fkname' }
+          : R extends { referencedRelation: value }
+          ? R & { match: 'refrel' }
+          : R extends { columns: [value] }
+          ? R & { match: 'col' }
+          : FindMatchingViewRelationships<Schema, Rest, value>
         : FindMatchingViewRelationships<Schema, Rest, value>
-      : FindMatchingViewRelationships<Schema, Rest, value>
+      : false
     : false
   : false
 
@@ -281,36 +295,39 @@ export type FindMatchingHintTableRelationships<
   Relationships extends GenericRelationship[],
   hint extends string,
   name extends string
-> = Relationships extends [infer R, ...infer Rest extends GenericRelationship[]]
-  ? R extends { referencedRelation: infer ReferencedRelation }
-    ? ReferencedRelation extends name
-      ? R extends { foreignKeyName: hint }
-        ? R & { match: 'fkname' }
-        : R extends { referencedRelation: hint }
-        ? R & { match: 'refrel' }
-        : R extends { columns: [hint] }
-        ? R & { match: 'col' }
+> = Relationships extends [infer R, ...infer Rest]
+  ? Rest extends GenericRelationship[]
+    ? R extends { referencedRelation: infer ReferencedRelation }
+      ? ReferencedRelation extends name
+        ? R extends { foreignKeyName: hint }
+          ? R & { match: 'fkname' }
+          : R extends { referencedRelation: hint }
+          ? R & { match: 'refrel' }
+          : R extends { columns: [hint] }
+          ? R & { match: 'col' }
+          : FindMatchingHintTableRelationships<Schema, Rest, hint, name>
         : FindMatchingHintTableRelationships<Schema, Rest, hint, name>
-      : FindMatchingHintTableRelationships<Schema, Rest, hint, name>
+      : false
     : false
   : false
-
 export type FindMatchingHintViewRelationships<
   Schema extends GenericSchema,
   Relationships extends GenericRelationship[],
   hint extends string,
   name extends string
-> = Relationships extends [infer R, ...infer Rest extends GenericRelationship[]]
-  ? R extends { referencedRelation: infer ReferencedRelation }
-    ? ReferencedRelation extends name
-      ? R extends { foreignKeyName: hint }
-        ? R & { match: 'fkname' }
-        : R extends { referencedRelation: hint }
-        ? R & { match: 'refrel' }
-        : R extends { columns: [hint] }
-        ? R & { match: 'col' }
+> = Relationships extends [infer R, ...infer Rest]
+  ? Rest extends GenericRelationship[]
+    ? R extends { referencedRelation: infer ReferencedRelation }
+      ? ReferencedRelation extends name
+        ? R extends { foreignKeyName: hint }
+          ? R & { match: 'fkname' }
+          : R extends { referencedRelation: hint }
+          ? R & { match: 'refrel' }
+          : R extends { columns: [hint] }
+          ? R & { match: 'col' }
+          : FindMatchingHintViewRelationships<Schema, Rest, hint, name>
         : FindMatchingHintViewRelationships<Schema, Rest, hint, name>
-      : FindMatchingHintViewRelationships<Schema, Rest, hint, name>
+      : false
     : false
   : false
 
@@ -337,8 +354,10 @@ type TableForwardRelationships<
 > = TName extends keyof TablesAndViews<Schema>
   ? UnionToArray<
       RecursivelyFindRelationships<Schema, TName, keyof TablesAndViews<Schema>>
-    > extends infer R extends (GenericRelationship & { from: keyof TablesAndViews<Schema> })[]
-    ? R
+    > extends infer R
+    ? R extends (GenericRelationship & { from: keyof TablesAndViews<Schema> })[]
+      ? R
+      : []
     : []
   : []
 
@@ -362,8 +381,7 @@ type FilterRelationships<R, TName, From> = R extends readonly (infer Rel)[]
     : never
   : never
 
-// Find a relationship from the parent to the childrens
-type ResolveForwardRelationship<
+export type ResolveForwardRelationship<
   Schema extends GenericSchema,
   Field extends Ast.FieldNode,
   CurrentTableOrView extends keyof TablesAndViews<Schema> & string
@@ -371,46 +389,46 @@ type ResolveForwardRelationship<
   Schema,
   TablesAndViews<Schema>[Field['name']]['Relationships'],
   Ast.FieldNode & { name: CurrentTableOrView; hint: Field['hint'] }
-> extends infer FoundByName extends GenericRelationship
-  ? {
-      referencedTable: TablesAndViews<Schema>[Field['name']]
-      relation: FoundByName
-      direction: 'forward'
-      from: Field['name']
-      type: 'found-by-name'
-    }
-  : // The Field['name'] can sometimes be a reference to the related foreign key
-  // In that case, we can't use the Field['name'] to get back the relations, instead, we will find all relations pointing
-  // to our current table or view, and search if we can find a match in it
-  FindFieldMatchingRelationships<
-      Schema,
-      TableForwardRelationships<Schema, CurrentTableOrView>,
-      Field
-    > extends infer FoundByMatch extends GenericRelationship & {
-      from: keyof TablesAndViews<Schema>
-    }
-  ? {
-      referencedTable: TablesAndViews<Schema>[FoundByMatch['from']]
-      relation: FoundByMatch
-      direction: 'forward'
-      from: CurrentTableOrView
-      type: 'found-by-match'
-    }
-  : // Forward relations can also alias other tables via tables joins relationships
-  // in such cases we crawl all the tables looking for a join table between our current table
-  // and the Field['name'] desired desitnation
-  FindJoinTableRelationship<
-      Schema,
-      CurrentTableOrView,
-      Field['name']
-    > extends infer FoundByJoinTable extends GenericRelationship
-  ? {
-      referencedTable: TablesAndViews<Schema>[FoundByJoinTable['referencedRelation']]
-      relation: FoundByJoinTable & { match: 'refrel' }
-      direction: 'forward'
-      from: CurrentTableOrView
-      type: 'found-by-join-table'
-    }
+> extends infer FoundByName
+  ? FoundByName extends GenericRelationship
+    ? {
+        referencedTable: TablesAndViews<Schema>[Field['name']]
+        relation: FoundByName
+        direction: 'forward'
+        from: Field['name']
+        type: 'found-by-name'
+      }
+    : FindFieldMatchingRelationships<
+        Schema,
+        TableForwardRelationships<Schema, CurrentTableOrView>,
+        Field
+      > extends infer FoundByMatch
+    ? FoundByMatch extends GenericRelationship & {
+        from: keyof TablesAndViews<Schema>
+      }
+      ? {
+          referencedTable: TablesAndViews<Schema>[FoundByMatch['from']]
+          relation: FoundByMatch
+          direction: 'forward'
+          from: CurrentTableOrView
+          type: 'found-by-match'
+        }
+      : FindJoinTableRelationship<
+          Schema,
+          CurrentTableOrView,
+          Field['name']
+        > extends infer FoundByJoinTable
+      ? FoundByJoinTable extends GenericRelationship
+        ? {
+            referencedTable: TablesAndViews<Schema>[FoundByJoinTable['referencedRelation']]
+            relation: FoundByJoinTable & { match: 'refrel' }
+            direction: 'forward'
+            from: CurrentTableOrView
+            type: 'found-by-join-table'
+          }
+        : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`>
+      : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`>
+    : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`>
   : SelectQueryError<`could not find the relation between ${CurrentTableOrView} and ${Field['name']}`>
 
 /**
@@ -431,7 +449,7 @@ type ResolveForwardRelationship<
  *   referencedColumns: ["id"]
  * }
  */
-export type FindJoinTableRelationship<
+type ResolveJoinTableRelationship<
   Schema extends GenericSchema,
   CurrentTableOrView extends keyof TablesAndViews<Schema> & string,
   FieldName extends string
@@ -447,6 +465,15 @@ export type FindJoinTableRelationship<
     : never
 }[keyof TablesAndViews<Schema>]
 
+export type FindJoinTableRelationship<
+  Schema extends GenericSchema,
+  CurrentTableOrView extends keyof TablesAndViews<Schema> & string,
+  FieldName extends string
+> = ResolveJoinTableRelationship<Schema, CurrentTableOrView, FieldName> extends infer Result
+  ? [Result] extends [never]
+    ? false
+    : Result
+  : never
 /**
  * Finds a matching relationship based on the FieldNode's name and optional hint.
  */
@@ -454,43 +481,35 @@ export type FindFieldMatchingRelationships<
   Schema extends GenericSchema,
   Relationships extends GenericRelationship[],
   Field extends Ast.FieldNode
-> = Field extends { hint: infer Hint extends string }
+> = Field extends { hint: string }
   ? FindMatchingHintTableRelationships<
       Schema,
       Relationships,
-      Hint,
+      Field['hint'],
       Field['name']
-    > extends infer TableRelationViaHint extends GenericRelationship
-    ? TableRelationViaHint & {
+    > extends GenericRelationship
+    ? FindMatchingHintTableRelationships<Schema, Relationships, Field['hint'], Field['name']> & {
         branch: 'found-in-table-via-hint'
         hint: Field['hint']
       }
     : FindMatchingHintViewRelationships<
         Schema,
         Relationships,
-        Hint,
+        Field['hint'],
         Field['name']
-      > extends infer TableViewViaHint extends GenericRelationship
-    ? TableViewViaHint & {
+      > extends GenericRelationship
+    ? FindMatchingHintViewRelationships<Schema, Relationships, Field['hint'], Field['name']> & {
         branch: 'found-in-view-via-hint'
         hint: Field['hint']
       }
     : SelectQueryError<'Failed to find matching relation via hint'>
-  : FindMatchingTableRelationships<
-      Schema,
-      Relationships,
-      Field['name']
-    > extends infer TableRelationViaName extends GenericRelationship
-  ? TableRelationViaName & {
+  : FindMatchingTableRelationships<Schema, Relationships, Field['name']> extends GenericRelationship
+  ? FindMatchingTableRelationships<Schema, Relationships, Field['name']> & {
       branch: 'found-in-table-via-name'
       name: Field['name']
     }
-  : FindMatchingViewRelationships<
-      Schema,
-      Relationships,
-      Field['name']
-    > extends infer ViewRelationViaName extends GenericRelationship
-  ? ViewRelationViaName & {
+  : FindMatchingViewRelationships<Schema, Relationships, Field['name']> extends GenericRelationship
+  ? FindMatchingViewRelationships<Schema, Relationships, Field['name']> & {
       branch: 'found-in-view-via-name'
       name: Field['name']
     }

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.17.1'
+export const version = '1.17.3'