@cloudbase/wx-cloud-client-sdk 1.6.1 → 1.7.1-alpha.0

package/lib/db/postgrest/PostgrestTransformBuilder.d.ts

@@ -0,0 +1,156 @@
+import PostgrestBuilder from "./PostgrestBuilder";
+import { InvalidMethodError } from "./PostgrestFilterBuilder";
+import { GetResult } from "./select-query-parser/result";
+import { GenericSchema, CheckMatchingArrayTypes, ClientServerOptions, MaxAffectedEnabled } from "./types";
+export default class PostgrestTransformBuilder<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, Result, RelationName = unknown, Relationships = unknown, Method = unknown> extends PostgrestBuilder<ClientOptions, Result> {
+    /**
+     * Perform a SELECT on the query result.
+     *
+     * By default, `.insert()`, `.update()`, `.upsert()`, and `.delete()` do not
+     * return modified rows. By calling this method, modified rows are returned in
+     * `data`.
+     *
+     * @param columns - The columns to retrieve, separated by commas
+     */
+    select<Query extends string = "*", NewResultOne = GetResult<Schema, Row, RelationName, Relationships, Query, ClientOptions>>(columns?: Query): PostgrestTransformBuilder<ClientOptions, Schema, Row, NewResultOne[], RelationName, Relationships, Method>;
+    order<ColumnName extends string & keyof Row>(column: ColumnName, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+        referencedTable?: undefined;
+    }): this;
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+        referencedTable?: string;
+    }): this;
+    /**
+     * @deprecated Use `options.referencedTable` instead of `options.foreignTable`
+     */
+    order<ColumnName extends string & keyof Row>(column: ColumnName, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+        foreignTable?: undefined;
+    }): this;
+    /**
+     * @deprecated Use `options.referencedTable` instead of `options.foreignTable`
+     */
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+        foreignTable?: string;
+    }): this;
+    /**
+     * Limit the query result by `count`.
+     *
+     * @param count - The maximum number of rows to return
+     * @param options - Named parameters
+     * @param options.referencedTable - Set this to limit rows of referenced
+     * tables instead of the parent table
+     * @param options.foreignTable - Deprecated, use `options.referencedTable`
+     * instead
+     */
+    limit(count: number, { foreignTable, referencedTable, }?: {
+        foreignTable?: string;
+        referencedTable?: string;
+    }): this;
+    /**
+     * Limit the query result by starting at an offset `from` and ending at the offset `to`.
+     * Only records within this range are returned.
+     * This respects the query order and if there is no order clause the range could behave unexpectedly.
+     * The `from` and `to` values are 0-based and inclusive: `range(1, 3)` will include the second, third
+     * and fourth rows of the query.
+     *
+     * @param from - The starting index from which to limit the result
+     * @param to - The last index to which to limit the result
+     * @param options - Named parameters
+     * @param options.referencedTable - Set this to limit rows of referenced
+     * tables instead of the parent table
+     * @param options.foreignTable - Deprecated, use `options.referencedTable`
+     * instead
+     */
+    range(from: number, to: number, { foreignTable, referencedTable, }?: {
+        foreignTable?: string;
+        referencedTable?: string;
+    }): this;
+    /**
+     * Set the AbortSignal for the fetch request.
+     *
+     * @param signal - The AbortSignal to use for the fetch request
+     */
+    abortSignal(signal: AbortSignal): this;
+    /**
+     * Return `data` as a single object instead of an array of objects.
+     *
+     * Query result must be one row (e.g. using `.limit(1)`), otherwise this
+     * returns an error.
+     */
+    single<ResultOne = Result extends (infer ResultOne)[] ? ResultOne : never>(): PostgrestBuilder<ClientOptions, ResultOne>;
+    /**
+     * Return `data` as a single object instead of an array of objects.
+     *
+     * Query result must be zero or one row (e.g. using `.limit(1)`), otherwise
+     * this returns an error.
+     */
+    maybeSingle<ResultOne = Result extends (infer ResultOne)[] ? ResultOne : never>(): PostgrestBuilder<ClientOptions, ResultOne | null>;
+    /**
+     * Return `data` as a string in CSV format.
+     */
+    csv(): PostgrestBuilder<ClientOptions, string>;
+    /**
+     * Return `data` as an object in [GeoJSON](https://geojson.org) format.
+     */
+    geojson(): PostgrestBuilder<ClientOptions, Record<string, unknown>>;
+    /**
+     * Return `data` as the EXPLAIN plan for the query.
+     *
+     * You need to enable the
+     * [db_plan_enabled](https://supabase.com/docs/guides/database/debugging-performance#enabling-explain)
+     * setting before using this method.
+     *
+     * @param options - Named parameters
+     *
+     * @param options.analyze - If `true`, the query will be executed and the
+     * actual run time will be returned
+     *
+     * @param options.verbose - If `true`, the query identifier will be returned
+     * and `data` will include the output columns of the query
+     *
+     * @param options.settings - If `true`, include information on configuration
+     * parameters that affect query planning
+     *
+     * @param options.buffers - If `true`, include information on buffer usage
+     *
+     * @param options.wal - If `true`, include information on WAL record generation
+     *
+     * @param options.format - The format of the output, can be `"text"` (default)
+     * or `"json"`
+     */
+    explain({ analyze, verbose, settings, buffers, wal, format, }?: {
+        analyze?: boolean;
+        verbose?: boolean;
+        settings?: boolean;
+        buffers?: boolean;
+        wal?: boolean;
+        format?: "json" | "text";
+    }): PostgrestBuilder<ClientOptions, string, false> | PostgrestBuilder<ClientOptions, Record<string, unknown>[], false>;
+    /**
+     * Rollback the query.
+     *
+     * `data` will still be returned, but the query is not committed.
+     */
+    rollback(): this;
+    /**
+     * Override the type of the returned `data`.
+     *
+     * @typeParam NewResult - The new result type to override with
+     * @deprecated Use overrideTypes<yourType, { merge: false }>() method at the end of your call chain instead
+     */
+    returns<NewResult>(): PostgrestTransformBuilder<ClientOptions, Schema, Row, CheckMatchingArrayTypes<Result, NewResult>, RelationName, Relationships, Method>;
+    /**
+     * Set the maximum number of rows that can be affected by the query.
+     * Only available in PostgREST v13+ and only works with PATCH and DELETE methods.
+     *
+     * @param value - The maximum number of rows that can be affected
+     */
+    maxAffected(value: number): MaxAffectedEnabled<ClientOptions["PostgrestVersion"]> extends true ? Method extends "PATCH" | "DELETE" | "RPC" ? this : InvalidMethodError<"maxAffected method only available on update or delete"> : InvalidMethodError<"maxAffected method only available on postgrest 13+">;
+}

package/lib/db/postgrest/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_HEADERS: {
+    "X-Client-Info": string;
+};

package/lib/db/postgrest/index.d.ts

@@ -0,0 +1,18 @@
+import PostgrestClient from "./PostgrestClient";
+import PostgrestQueryBuilder from "./PostgrestQueryBuilder";
+import PostgrestFilterBuilder from "./PostgrestFilterBuilder";
+import PostgrestTransformBuilder from "./PostgrestTransformBuilder";
+import PostgrestBuilder from "./PostgrestBuilder";
+import PostgrestError from "./PostgrestError";
+export { PostgrestClient, PostgrestQueryBuilder, PostgrestFilterBuilder, PostgrestTransformBuilder, PostgrestBuilder, PostgrestError, };
+declare const _default: {
+    PostgrestClient: typeof PostgrestClient;
+    PostgrestQueryBuilder: typeof PostgrestQueryBuilder;
+    PostgrestFilterBuilder: typeof PostgrestFilterBuilder;
+    PostgrestTransformBuilder: typeof PostgrestTransformBuilder;
+    PostgrestBuilder: typeof PostgrestBuilder;
+    PostgrestError: typeof PostgrestError;
+};
+export default _default;
+export type { PostgrestResponse, PostgrestResponseFailure, PostgrestResponseSuccess, PostgrestSingleResponse, PostgrestMaybeSingleResponse, ClientServerOptions, GetGenericDatabaseWithOptions, } from "./types";
+export type { GetResult as UnstableGetResult } from "./select-query-parser/result";

package/lib/db/postgrest/select-query-parser/parser.d.ts

@@ -0,0 +1,302 @@
+import { SimplifyDeep } from "../types";
+import { JsonPathToAccessor } from "./utils";
+/**
+ * Parses a query.
+ * A query is a sequence of nodes, separated by `,`, ensuring that there is
+ * no remaining input after all nodes have been parsed.
+ *
+ * Returns an array of parsed nodes, or an error.
+ */
+export type ParseQuery<Query extends string> = string extends Query ? GenericStringError : 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>>;
+/**
+ * Notes: all `Parse*` types assume that their input strings have their whitespace
+ * removed. They return tuples of ["Return Value", "Remainder of text"] or
+ * a `ParserError`.
+ */
+/**
+ * Parses a sequence of nodes, separated by `,`.
+ *
+ * Returns a tuple of ["Parsed fields", "Remainder of text"] or an error.
+ */
+type ParseNodes<Input extends string> = string extends Input ? GenericStringError : ParseNodesHelper<Input, []>;
+type ParseNodesHelper<Input extends string, Nodes extends Ast.Node[]> = ParseNode<Input> extends [infer Node, `${infer 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:
+ * - `*`
+ * - a field, as defined above
+ * - a renamed field, `renamed_field:field`
+ * - a spread field, `...field`
+ */
+type ParseNode<Input extends string> = Input extends "" ? ParserError<"Empty string"> : Input extends `*${infer Remainder}` ? [Ast.StarNode, EatWhitespace<Remainder>] : Input extends `...${infer 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 _}` ? ParseField<Input> : EatWhitespace<Remainder> extends `:${infer 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}\``> : ParseField<Input> : ParserError<`Expected identifier at \`${Input}\``>;
+/**
+ * Parses a field without preceding alias.
+ * A field is one of the following:
+ * - a top-level `count` field: https://docs.postgrest.org/en/v12/references/api/aggregate_functions.html#the-case-of-count
+ * - a field with an embedded resource
+ *   - `field(nodes)`
+ *   - `field!hint(nodes)`
+ *   - `field!inner(nodes)`
+ *   - `field!left(nodes)`
+ *   - `field!hint!inner(nodes)`
+ *   - `field!hint!left(nodes)`
+ * - a field without an embedded resource (see {@link ParseNonEmbeddedResourceField})
+ */
+type ParseField<Input extends string> = Input extends "" ? ParserError<"Empty string"> : ParseIdentifier<Input> extends [infer Name, `${infer Remainder}`] ? Name extends "count" ? ParseCountField<Input> : Remainder extends `!inner${infer Remainder}` ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
+    infer Children,
+    `${infer Remainder}`
+] ? Children extends Ast.Node[] ? [
+    {
+        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,
+    `${infer Remainder}`
+] ? Children extends Ast.Node[] ? [
+    {
+        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>}\``> : EatWhitespace<Remainder> extends `!${infer Remainder}` ? ParseIdentifier<EatWhitespace<Remainder>> extends [
+    infer Hint,
+    `${infer Remainder}`
+] ? EatWhitespace<Remainder> extends `!inner${infer Remainder}` ? ParseEmbeddedResource<EatWhitespace<Remainder>> extends [
+    infer Children,
+    `${infer Remainder}`
+] ? Children extends Ast.Node[] ? [
+    {
+        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,
+    `${infer Remainder}`
+] ? Children extends Ast.Node[] ? [
+    {
+        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,
+    `${infer Remainder}`
+] ? Children extends Ast.Node[] ? [
+    {
+        type: "field";
+        name: Name;
+        children: Children;
+    },
+    EatWhitespace<Remainder>
+] : ParserError<"Invalid children array in field"> : ParseEmbeddedResource<EatWhitespace<Remainder>> : ParseNonEmbeddedResourceField<Input> : ParserError<`Expected identifier at \`${Input}\``>;
+type ParseCountField<Input extends string> = ParseIdentifier<Input> extends [
+    "count",
+    `${infer Remainder}`
+] ? (EatWhitespace<Remainder> extends `()${infer Remainder_}` ? EatWhitespace<Remainder_> : EatWhitespace<Remainder>) extends `${infer Remainder}` ? Remainder extends `::${infer _}` ? ParseFieldTypeCast<Remainder> extends [
+    infer CastType,
+    `${infer Remainder}`
+] ? [
+    {
+        type: "field";
+        name: "count";
+        aggregateFunction: "count";
+        castType: CastType;
+    },
+    Remainder
+] : ParseFieldTypeCast<Remainder> : [
+    {
+        type: "field";
+        name: "count";
+        aggregateFunction: "count";
+    },
+    Remainder
+] : never : ParserError<`Expected "count" at \`${Input}\``>;
+/**
+ * Parses an embedded resource, which is an opening `(`, followed by a sequence of
+ * 0 or more nodes separated by `,`, then a closing `)`.
+ *
+ * Returns a tuple of ["Parsed fields", "Remainder of text"], an error,
+ * or the original string input indicating that no opening `(` was found.
+ */
+type ParseEmbeddedResource<Input extends string> = Input extends `(${infer Remainder}` ? EatWhitespace<Remainder> extends `)${infer Remainder}` ? [[], 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}\``>;
+/**
+ * Parses a field excluding embedded resources, without preceding field renaming.
+ * This is one of the following:
+ * - `field`
+ * - `field.aggregate()`
+ * - `field.aggregate()::type`
+ * - `field::type`
+ * - `field::type.aggregate()`
+ * - `field::type.aggregate()::type`
+ * - `field->json...`
+ * - `field->json.aggregate()`
+ * - `field->json.aggregate()::type`
+ * - `field->json::type`
+ * - `field->json::type.aggregate()`
+ * - `field->json::type.aggregate()::type`
+ */
+type ParseNonEmbeddedResourceField<Input extends string> = ParseIdentifier<Input> extends [infer Name, `${infer Remainder}`] ? (Remainder extends `->${infer PathAndRest}` ? ParseJsonAccessor<Remainder> extends [
+    infer PropertyName,
+    infer PropertyType,
+    `${infer Remainder}`
+] ? [
+    {
+        type: "field";
+        name: Name;
+        alias: PropertyName;
+        castType: PropertyType;
+        jsonPath: JsonPathToAccessor<PathAndRest extends `${infer Path},${string}` ? Path : PathAndRest>;
+    },
+    Remainder
+] : ParseJsonAccessor<Remainder> : [{
+    type: "field";
+    name: Name;
+}, Remainder]) extends infer Parsed ? Parsed extends [infer Field, `${infer Remainder}`] ? (Remainder extends `::${infer _}` ? ParseFieldTypeCast<Remainder> extends [
+    infer CastType,
+    `${infer Remainder}`
+] ? [Omit<Field, "castType"> & {
+    castType: CastType;
+}, Remainder] : ParseFieldTypeCast<Remainder> : [Field, Remainder]) extends infer Parsed ? Parsed extends [infer Field, `${infer Remainder}`] ? Remainder extends `.${infer _}` ? ParseFieldAggregation<Remainder> extends [
+    infer AggregateFunction,
+    `${infer Remainder}`
+] ? Remainder extends `::${infer _}` ? ParseFieldTypeCast<Remainder> extends [
+    infer CastType,
+    `${infer Remainder}`
+] ? [
+    Omit<Field, "castType"> & {
+        aggregateFunction: AggregateFunction;
+        castType: CastType;
+    },
+    Remainder
+] : ParseFieldTypeCast<Remainder> : [
+    Field & {
+        aggregateFunction: AggregateFunction;
+    },
+    Remainder
+] : ParseFieldAggregation<Remainder> : [Field, Remainder] : Parsed : never : Parsed : never : ParserError<`Expected identifier at \`${Input}\``>;
+/**
+ * Parses a JSON property accessor of the shape `->a->b->c`. The last accessor in
+ * the series may convert to text by using the ->> operator instead of ->.
+ *
+ * Returns a tuple of ["Last property name", "Last property type", "Remainder of text"]
+ */
+type ParseJsonAccessor<Input extends string> = Input extends `->${infer Remainder}` ? Remainder extends `>${infer Remainder}` ? ParseIdentifier<Remainder> extends [infer Name, `${infer Remainder}`] ? [Name, "text", EatWhitespace<Remainder>] : ParserError<"Expected property name after `->>`"> : ParseIdentifier<Remainder> extends [infer Name, `${infer Remainder}`] ? ParseJsonAccessor<Remainder> extends [
+    infer PropertyName,
+    infer PropertyType,
+    `${infer Remainder}`
+] ? [PropertyName, PropertyType, EatWhitespace<Remainder>] : [Name, "json", EatWhitespace<Remainder>] : ParserError<"Expected property name after `->`"> : ParserError<"Expected ->">;
+/**
+ * Parses a field typecast (`::type`), returning a tuple of ["Type", "Remainder of text"].
+ */
+type ParseFieldTypeCast<Input extends string> = EatWhitespace<Input> extends `::${infer Remainder}` ? ParseIdentifier<EatWhitespace<Remainder>> extends [
+    `${infer CastType}`,
+    `${infer Remainder}`
+] ? [CastType, EatWhitespace<Remainder>] : ParserError<`Invalid type for \`::\` operator at \`${Remainder}\``> : ParserError<"Expected ::">;
+/**
+ * Parses a field aggregation (`.max()`), returning a tuple of ["Aggregate function", "Remainder of text"]
+ */
+type ParseFieldAggregation<Input extends string> = EatWhitespace<Input> extends `.${infer Remainder}` ? ParseIdentifier<EatWhitespace<Remainder>> extends [
+    `${infer FunctionName}`,
+    `${infer Remainder}`
+] ? FunctionName extends Token.AggregateFunction ? EatWhitespace<Remainder> extends `()${infer Remainder}` ? [FunctionName, EatWhitespace<Remainder>] : ParserError<`Expected \`()\` after \`.\` operator \`${FunctionName}\``> : ParserError<`Invalid type for \`.\` operator \`${FunctionName}\``> : ParserError<`Invalid type for \`.\` operator at \`${Remainder}\``> : ParserError<"Expected .">;
+/**
+ * Parses a (possibly double-quoted) identifier.
+ * Identifiers are sequences of 1 or more letters.
+ */
+type ParseIdentifier<Input extends string> = ParseLetters<Input> extends [
+    infer Name,
+    `${infer Remainder}`
+] ? [Name, EatWhitespace<Remainder>] : ParseQuotedLetters<Input> extends [infer Name, `${infer Remainder}`] ? [Name, EatWhitespace<Remainder>] : ParserError<`No (possibly double-quoted) identifier at \`${Input}\``>;
+/**
+ * Parse a consecutive sequence of 1 or more letter, where letters are `[0-9a-zA-Z_]`.
+ */
+type ParseLetters<Input extends string> = string extends Input ? GenericStringError : ParseLettersHelper<Input, ""> extends [
+    `${infer Letters}`,
+    `${infer Remainder}`
+] ? Letters extends "" ? ParserError<`Expected letter at \`${Input}\``> : [Letters, Remainder] : ParseLettersHelper<Input, "">;
+type ParseLettersHelper<Input extends string, Acc extends string> = string extends Input ? GenericStringError : Input extends `${infer L}${infer Remainder}` ? L extends Token.Letter ? ParseLettersHelper<Remainder, `${Acc}${L}`> : [Acc, Input] : [Acc, ""];
+/**
+ * Parse a consecutive sequence of 1 or more double-quoted letters,
+ * where letters are `[^"]`.
+ */
+type ParseQuotedLetters<Input extends string> = string extends Input ? GenericStringError : Input extends `"${infer Remainder}` ? ParseQuotedLettersHelper<Remainder, ""> extends [
+    `${infer Letters}`,
+    `${infer Remainder}`
+] ? Letters extends "" ? ParserError<`Expected string at \`${Remainder}\``> : [Letters, Remainder] : ParseQuotedLettersHelper<Remainder, ""> : ParserError<`Not a double-quoted string at \`${Input}\``>;
+type ParseQuotedLettersHelper<Input extends string, Acc extends string> = string extends Input ? GenericStringError : Input extends `${infer L}${infer Remainder}` ? L extends '"' ? [Acc, Remainder] : ParseQuotedLettersHelper<Remainder, `${Acc}${L}`> : ParserError<`Missing closing double-quote in \`"${Acc}${Input}\``>;
+/**
+ * Trims whitespace from the left of the input.
+ */
+type EatWhitespace<Input extends string> = string extends Input ? GenericStringError : Input extends `${Token.Whitespace}${infer Remainder}` ? EatWhitespace<Remainder> : Input;
+/**
+ * Creates a new {@link ParserError} if the given input is not already a parser error.
+ */
+type CreateParserErrorIfRequired<Input, Message extends string> = Input extends ParserError<string> ? Input : ParserError<Message>;
+/**
+ * Parser errors.
+ */
+export type ParserError<Message extends string> = {
+    error: true;
+} & Message;
+type GenericStringError = ParserError<"Received a generic string">;
+export declare namespace Ast {
+    type Node = FieldNode | StarNode | SpreadNode;
+    type FieldNode = {
+        type: "field";
+        name: string;
+        alias?: string;
+        hint?: string;
+        innerJoin?: true;
+        castType?: string;
+        jsonPath?: string;
+        aggregateFunction?: Token.AggregateFunction;
+        children?: Node[];
+    };
+    type StarNode = {
+        type: "star";
+    };
+    type SpreadNode = {
+        type: "spread";
+        target: FieldNode & {
+            children: Node[];
+        };
+    };
+}
+declare namespace Token {
+    export type Whitespace = " " | "\n" | "\t";
+    type LowerAlphabet = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+    type Alphabet = LowerAlphabet | Uppercase<LowerAlphabet>;
+    type Digit = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "0";
+    export type Letter = Alphabet | Digit | "_";
+    export type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+    export {};
+}
+export {};

package/lib/db/postgrest/select-query-parser/result.d.ts

@@ -0,0 +1,156 @@
+import { ClientServerOptions, GenericTable } from "../types";
+import { ContainsNull, GenericRelationship, PostgreSQLTypes } from "./types";
+import { Ast, ParseQuery } from "./parser";
+import { AggregateFunctions, ExtractFirstProperty, GenericSchema, IsNonEmptyArray, Prettify, TablesAndViews, TypeScriptTypes } from "./types";
+import { CheckDuplicateEmbededReference, GetComputedFields, GetFieldNodeResultName, IsAny, IsRelationNullable, IsStringUnion, JsonPathToType, ResolveRelationship, SelectQueryError } from "./utils";
+export type SpreadOnManyEnabled<PostgrestVersion extends string | undefined> = PostgrestVersion extends `13${string}` ? true : false;
+/**
+ * Main entry point for constructing the result type of a PostgREST query.
+ *
+ * @param Schema - Database schema.
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Relationships - Relationships of the current table.
+ * @param Query - The select query string literal to parse.
+ */
+export type GetResult<Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName, Relationships, Query extends string, ClientOptions extends ClientServerOptions> = IsAny<Schema> extends true ? ParseQuery<Query> extends infer ParsedQuery ? ParsedQuery extends Ast.Node[] ? RelationName extends string ? ProcessNodesWithoutSchema<ParsedQuery> : any : ParsedQuery : any : Relationships extends null ? 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[] ? RelationName extends string ? Relationships extends GenericRelationship[] ? ProcessNodes<ClientOptions, Schema, Row, RelationName, Relationships, ParsedQuery> : SelectQueryError<"Invalid Relationships cannot infer result type"> : SelectQueryError<"Invalid RelationName cannot infer result type"> : ParsedQuery : never;
+type ProcessSimpleFieldWithoutSchema<Field extends Ast.FieldNode> = Field["aggregateFunction"] extends AggregateFunctions ? {
+    [K in GetFieldNodeResultName<Field>]: Field["castType"] extends PostgreSQLTypes ? TypeScriptTypes<Field["castType"]> : number;
+} : {
+    [K in GetFieldNodeResultName<Field>]: Field["castType"] extends PostgreSQLTypes ? TypeScriptTypes<Field["castType"]> : any;
+};
+type ProcessFieldNodeWithoutSchema<Node extends Ast.FieldNode> = IsNonEmptyArray<Node["children"]> extends true ? {
+    [K in GetFieldNodeResultName<Node>]: Node["children"] extends Ast.Node[] ? ProcessNodesWithoutSchema<Node["children"]>[] : ProcessSimpleFieldWithoutSchema<Node>;
+} : ProcessSimpleFieldWithoutSchema<Node>;
+/**
+ * Processes a single Node without schema and returns the resulting TypeScript type.
+ */
+type ProcessNodeWithoutSchema<Node extends Ast.Node> = Node extends Ast.StarNode ? any : Node extends Ast.SpreadNode ? Node["target"]["children"] extends Ast.StarNode[] ? any : Node["target"]["children"] extends Ast.FieldNode[] ? {
+    [P in Node["target"]["children"][number] as GetFieldNodeResultName<P>]: P["castType"] extends PostgreSQLTypes ? TypeScriptTypes<P["castType"]> : any;
+} : any : Node extends Ast.FieldNode ? ProcessFieldNodeWithoutSchema<Node> : any;
+/**
+ * Processes nodes when Schema is any, providing basic type inference
+ */
+type ProcessNodesWithoutSchema<Nodes extends Ast.Node[], Acc extends Record<string, unknown> = {}> = 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>;
+/**
+ * Processes a single Node from a select chained after a rpc call
+ *
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current rpc function
+ * @param NodeType - The Node to process.
+ */
+export type ProcessRPCNode<Row extends Record<string, unknown>, RelationName extends string, NodeType extends Ast.Node> = NodeType["type"] extends Ast.StarNode["type"] ? Row : 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
+ */
+export type RPCCallNodes<Nodes extends Ast.Node[], RelationName extends string, Row extends Record<string, unknown>, Acc extends Record<string, unknown> = {}> = 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>;
+/**
+ * Recursively processes an array of Nodes and accumulates the resulting TypeScript type.
+ *
+ * @param Schema - Database schema.
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Relationships - Relationships of the current table.
+ * @param Nodes - An array of AST nodes to process.
+ * @param Acc - Accumulator for the constructed type.
+ */
+export type ProcessNodes<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], Nodes extends Ast.Node[], Acc extends Record<string, unknown> = {}> = CheckDuplicateEmbededReference<Schema, RelationName, Relationships, Nodes> extends false ? Nodes extends [infer FirstNode, ...infer RestNodes] ? FirstNode extends Ast.Node ? RestNodes extends Ast.Node[] ? ProcessNode<ClientOptions, Schema, Row, RelationName, Relationships, FirstNode> extends infer FieldResult ? FieldResult extends Record<string, unknown> ? ProcessNodes<ClientOptions, 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>>;
+/**
+ * Processes a single Node and returns the resulting TypeScript type.
+ *
+ * @param Schema - Database schema.
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Relationships - Relationships of the current table.
+ * @param NodeType - The Node to process.
+ */
+export type ProcessNode<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], NodeType extends Ast.Node> = NodeType["type"] extends Ast.StarNode["type"] ? GetComputedFields<Schema, RelationName> extends never ? Row : Omit<Row, GetComputedFields<Schema, RelationName>> : NodeType["type"] extends Ast.SpreadNode["type"] ? ProcessSpreadNode<ClientOptions, Schema, Row, RelationName, Relationships, Extract<NodeType, Ast.SpreadNode>> : NodeType["type"] extends Ast.FieldNode["type"] ? ProcessFieldNode<ClientOptions, Schema, Row, RelationName, Relationships, Extract<NodeType, Ast.FieldNode>> : SelectQueryError<"Unsupported node type.">;
+/**
+ * Processes a FieldNode and returns the resulting TypeScript type.
+ *
+ * @param Schema - Database schema.
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Relationships - Relationships of the current table.
+ * @param Field - The FieldNode to process.
+ */
+type ProcessFieldNode<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], Field extends Ast.FieldNode> = Field["children"] extends [] ? {} : IsNonEmptyArray<Field["children"]> extends true ? ProcessEmbeddedResource<ClientOptions, Schema, Relationships, Field, RelationName> : ProcessSimpleField<Row, RelationName, Field>;
+type ResolveJsonPathType<Value, Path extends string | undefined, CastType extends PostgreSQLTypes> = Path extends string ? JsonPathToType<Value, Path> extends never ? TypeScriptTypes<CastType> : JsonPathToType<Value, Path> extends infer PathResult ? PathResult extends string ? PathResult : IsStringUnion<PathResult> extends true ? PathResult : CastType extends "json" ? PathResult : TypeScriptTypes<CastType> : TypeScriptTypes<CastType> : TypeScriptTypes<CastType>;
+/**
+ * Processes a simple field (without embedded resources).
+ *
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Field - The FieldNode to process.
+ */
+type ProcessSimpleField<Row extends Record<string, unknown>, RelationName extends string, Field extends Ast.FieldNode> = Field["name"] extends keyof Row | "count" ? Field["aggregateFunction"] extends AggregateFunctions ? {
+    [K in GetFieldNodeResultName<Field>]: Field["castType"] extends PostgreSQLTypes ? TypeScriptTypes<Field["castType"]> : number;
+} : {
+    [K in GetFieldNodeResultName<Field>]: Field["castType"] extends PostgreSQLTypes ? ResolveJsonPathType<Row[Field["name"]], Field["jsonPath"], Field["castType"]> : Row[Field["name"]];
+} : SelectQueryError<`column '${Field["name"]}' does not exist on '${RelationName}'.`>;
+/**
+ * Processes an embedded resource (relation).
+ *
+ * @param Schema - Database schema.
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Relationships - Relationships of the current table.
+ * @param Field - The FieldNode to process.
+ */
+export type ProcessEmbeddedResource<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews<Schema> & string> = ResolveRelationship<Schema, Relationships, Field, CurrentTableOrView> extends infer Resolved ? Resolved extends {
+    referencedTable: Pick<GenericTable, "Row" | "Relationships">;
+    relation: GenericRelationship & {
+        match: "refrel" | "col" | "fkname";
+    };
+    direction: string;
+} ? ProcessEmbeddedResourceResult<ClientOptions, Schema, Resolved, Field, CurrentTableOrView> : {
+    [K in GetFieldNodeResultName<Field>]: Resolved;
+} : {
+    [K in GetFieldNodeResultName<Field>]: SelectQueryError<"Failed to resolve relationship."> & string;
+};
+/**
+ * Helper type to process the result of an embedded resource.
+ */
+type ProcessEmbeddedResourceResult<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Resolved extends {
+    referencedTable: Pick<GenericTable, "Row" | "Relationships">;
+    relation: GenericRelationship & {
+        match: "refrel" | "col" | "fkname";
+    };
+    direction: string;
+}, Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews<Schema>> = ProcessNodes<ClientOptions, Schema, Resolved["referencedTable"]["Row"], Field["name"], Resolved["referencedTable"]["Relationships"], Field["children"] extends undefined ? [] : Exclude<Field["children"], undefined> extends Ast.Node[] ? Exclude<Field["children"], undefined> : []> extends infer ProcessedChildren ? {
+    [K in GetFieldNodeResultName<Field>]: Resolved["direction"] extends "forward" ? Field extends {
+        innerJoin: true;
+    } ? Resolved["relation"]["isOneToOne"] extends true ? ProcessedChildren : ProcessedChildren[] : Resolved["relation"]["isOneToOne"] extends true ? ProcessedChildren | null : ProcessedChildren[] : Resolved["relation"]["referencedRelation"] extends CurrentTableOrView ? Resolved["relation"]["match"] extends "col" ? IsRelationNullable<TablesAndViews<Schema>[CurrentTableOrView], Resolved["relation"]> extends true ? ProcessedChildren | null : ProcessedChildren : ProcessedChildren[] : IsRelationNullable<TablesAndViews<Schema>[CurrentTableOrView], Resolved["relation"]> extends true ? Field extends {
+        innerJoin: true;
+    } ? ProcessedChildren : ProcessedChildren | null : ProcessedChildren;
+} : {
+    [K in GetFieldNodeResultName<Field>]: SelectQueryError<"Failed to process embedded resource nodes."> & string;
+};
+/**
+ * Processes a SpreadNode by processing its target node.
+ *
+ * @param Schema - Database schema.
+ * @param Row - The type of a row in the current table.
+ * @param RelationName - The name of the current table or view.
+ * @param Relationships - Relationships of the current table.
+ * @param Spread - The SpreadNode to process.
+ */
+type ProcessSpreadNode<ClientOptions extends ClientServerOptions, Schema extends GenericSchema, Row extends Record<string, unknown>, RelationName extends string, Relationships extends GenericRelationship[], Spread extends Ast.SpreadNode> = ProcessNode<ClientOptions, Schema, Row, RelationName, Relationships, Spread["target"]> extends infer Result ? Result extends SelectQueryError<infer E> ? SelectQueryError<E> : ExtractFirstProperty<Result> extends unknown[] ? SpreadOnManyEnabled<ClientOptions["PostgrestVersion"]> extends true ? ProcessManyToManySpreadNodeResult<Result> : {
+    [K in Spread["target"]["name"]]: SelectQueryError<`"${RelationName}" and "${Spread["target"]["name"]}" do not form a many-to-one or one-to-one relationship spread not possible`>;
+} : ProcessSpreadNodeResult<Result> : never;
+/**
+ * Helper type to process the result of a many-to-many spread node.
+ * Converts all fields in the spread object into arrays.
+ */
+type ProcessManyToManySpreadNodeResult<Result> = Result extends Record<string, SelectQueryError<string> | null> ? Result : ExtractFirstProperty<Result> extends infer SpreadedObject ? SpreadedObject extends Array<Record<string, unknown>> ? {
+    [K in keyof SpreadedObject[number]]: Array<SpreadedObject[number][K]>;
+} : SelectQueryError<"An error occurred spreading the many-to-many object"> : SelectQueryError<"An error occurred spreading the many-to-many object">;
+/**
+ * Helper type to process the result of a spread node.
+ */
+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> : SelectQueryError<"An error occurred spreading the object">;
+export {};