@cloudbase/wx-cloud-client-sdk 1.6.1 → 1.7.1

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

@@ -0,0 +1,33 @@
+import type { GenericRelationship, GenericSchema, GenericTable, Prettify } from "../types";
+export type { GenericRelationship, GenericSchema, GenericTable, Prettify };
+export type AggregateWithoutColumnFunctions = "count";
+export type AggregateWithColumnFunctions = "sum" | "avg" | "min" | "max" | AggregateWithoutColumnFunctions;
+export type AggregateFunctions = AggregateWithColumnFunctions;
+export type Json = string | number | boolean | null | {
+    [key: string]: Json | undefined;
+} | Json[];
+type PostgresSQLNumberTypes = "int2" | "int4" | "int8" | "float4" | "float8" | "numeric";
+type PostgresSQLStringTypes = "bytea" | "bpchar" | "varchar" | "date" | "text" | "citext" | "time" | "timetz" | "timestamp" | "timestamptz" | "uuid" | "vector";
+type SingleValuePostgreSQLTypes = PostgresSQLNumberTypes | PostgresSQLStringTypes | "bool" | "json" | "jsonb" | "void" | "record" | string;
+type ArrayPostgreSQLTypes = `_${SingleValuePostgreSQLTypes}`;
+type TypeScriptSingleValueTypes<T extends SingleValuePostgreSQLTypes> = T extends "bool" ? boolean : T extends PostgresSQLNumberTypes ? number : T extends PostgresSQLStringTypes ? string : T extends "json" | "jsonb" ? Json : T extends "void" ? undefined : T extends "record" ? Record<string, unknown> : unknown;
+type StripUnderscore<T extends string> = T extends `_${infer U}` ? U : T;
+export type PostgreSQLTypes = SingleValuePostgreSQLTypes | ArrayPostgreSQLTypes;
+export type TypeScriptTypes<T extends PostgreSQLTypes> = T extends ArrayPostgreSQLTypes ? TypeScriptSingleValueTypes<StripUnderscore<Extract<T, SingleValuePostgreSQLTypes>>>[] : TypeScriptSingleValueTypes<T>;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+export type Push<T extends any[], V> = [...T, V];
+export type UnionToTuple<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = N extends true ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+export type UnionToArray<T> = UnionToTuple<T>;
+export type ExtractFirstProperty<T> = T extends {
+    [K in keyof T]: infer U;
+} ? U : never;
+export type ContainsNull<T> = null extends T ? true : false;
+export type IsNonEmptyArray<T> = Exclude<T, undefined> extends readonly [
+    unknown,
+    ...unknown[]
+] ? true : false;
+export type TablesAndViews<Schema extends GenericSchema> = Schema["Tables"] & Exclude<Schema["Views"], "">;
+export type GetTableRelationships<Schema extends GenericSchema, Tname extends string> = TablesAndViews<Schema>[Tname] extends {
+    Relationships: infer R;
+} ? R : false;

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

@@ -0,0 +1,266 @@
+import { Ast } from "./parser";
+import { AggregateFunctions, ContainsNull, GenericRelationship, GenericSchema, GenericTable, IsNonEmptyArray, TablesAndViews, UnionToArray } from "./types";
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type SelectQueryError<Message extends string> = {
+    error: true;
+} & Message;
+export type DeduplicateRelationships<T extends readonly unknown[]> = T extends readonly [infer First, ...infer Rest] ? First extends Rest[number] ? DeduplicateRelationships<Rest extends readonly unknown[] ? Rest : []> : [
+    First,
+    ...DeduplicateRelationships<Rest extends readonly unknown[] ? Rest : []>
+] : T;
+export type GetFieldNodeResultName<Field extends Ast.FieldNode> = Field["alias"] extends string ? Field["alias"] : Field["aggregateFunction"] extends AggregateFunctions ? Field["aggregateFunction"] : Field["name"];
+type FilterRelationNodes<Nodes extends Ast.Node[]> = UnionToArray<{
+    [K in keyof Nodes]: Nodes[K] extends Ast.SpreadNode ? Nodes[K]["target"] : Nodes[K] extends Ast.FieldNode ? IsNonEmptyArray<Nodes[K]["children"]> extends true ? Nodes[K] : never : never;
+}[number]>;
+type ResolveRelationships<Schema extends GenericSchema, RelationName extends string, Relationships extends GenericRelationship[], Nodes extends Ast.FieldNode[]> = UnionToArray<{
+    [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];
+/**
+ * Checks if a relation is implicitly referenced twice, requiring disambiguation
+ */
+type IsDoubleReference<T, U> = T extends {
+    referencedTable: infer RT;
+    fieldName: infer FN;
+    match: infer M;
+} ? M extends "col" | "refrel" ? U extends {
+    referencedTable: RT;
+    fieldName: FN;
+    match: M;
+} ? true : false : false : false;
+/**
+ * Compares one element with all other elements in the array to find duplicates
+ */
+type CheckDuplicates<Arr extends any[], Current> = Arr extends [
+    infer Head,
+    ...infer Tail
+] ? IsDoubleReference<Current, Head> extends true ? Head | CheckDuplicates<Tail, Current> : CheckDuplicates<Tail, Current> : never;
+/**
+ * Iterates over the elements of the array to find duplicates
+ */
+type FindDuplicatesWithinDeduplicated<Arr extends any[]> = Arr extends [
+    infer Head,
+    ...infer Tail
+] ? CheckDuplicates<Tail, Head> | FindDuplicatesWithinDeduplicated<Tail> : never;
+type FindDuplicates<Arr extends any[]> = FindDuplicatesWithinDeduplicated<DeduplicateRelationships<Arr>>;
+export type CheckDuplicateEmbededReference<Schema extends GenericSchema, RelationName extends string, Relationships extends GenericRelationship[], Nodes extends Ast.Node[]> = 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 : false : false;
+/**
+ * Returns a boolean representing whether there is a foreign key referencing
+ * a given relation.
+ */
+type HasFKeyToFRel<FRelName, Relationships> = Relationships extends [infer R] ? R extends {
+    referencedRelation: FRelName;
+} ? true : false : Relationships extends [infer R, ...infer Rest] ? HasFKeyToFRel<FRelName, [R]> extends true ? true : HasFKeyToFRel<FRelName, Rest> : false;
+/**
+ * Checks if there is more than one relation to a given foreign relation name in the Relationships.
+ */
+type HasMultipleFKeysToFRelDeduplicated<FRelName, Relationships> = Relationships extends [infer R, ...infer Rest] ? R extends {
+    referencedRelation: FRelName;
+} ? HasFKeyToFRel<FRelName, Rest> extends true ? true : HasMultipleFKeysToFRelDeduplicated<FRelName, Rest> : HasMultipleFKeysToFRelDeduplicated<FRelName, Rest> : false;
+type HasMultipleFKeysToFRel<FRelName, Relationships extends unknown[]> = HasMultipleFKeysToFRelDeduplicated<FRelName, DeduplicateRelationships<Relationships>>;
+type CheckRelationshipError<Schema extends GenericSchema, Relationships extends GenericRelationship[], CurrentTableOrView extends keyof TablesAndViews<Schema> & string, FoundRelation> = FoundRelation extends SelectQueryError<string> ? FoundRelation : FoundRelation extends {
+    relation: {
+        referencedRelation: infer RelatedRelationName;
+        name: string;
+    };
+    direction: "reverse";
+} ? RelatedRelationName extends string ? 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> ?`> : FoundRelation : never : FoundRelation extends {
+    relation: {
+        referencedRelation: infer RelatedRelationName;
+        name: string;
+    };
+    direction: "forward";
+    from: infer From;
+} ? 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
+ */
+export type ResolveRelationship<Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews<Schema> & string> = ResolveReverseRelationship<Schema, Relationships, Field, CurrentTableOrView> extends infer ReverseRelationship ? ReverseRelationship extends false ? CheckRelationshipError<Schema, Relationships, CurrentTableOrView, ResolveForwardRelationship<Schema, Field, CurrentTableOrView>> : CheckRelationshipError<Schema, Relationships, CurrentTableOrView, ReverseRelationship> : never;
+/**
+ * Resolves reverse relationships (from children to parent)
+ */
+type ResolveReverseRelationship<Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews<Schema> & string> = FindFieldMatchingRelationships<Schema, Relationships, Field> extends infer FoundRelation ? FoundRelation extends never ? false : FoundRelation extends {
+    referencedRelation: infer RelatedRelationName;
+} ? RelatedRelationName extends string ? RelatedRelationName extends keyof TablesAndViews<Schema> ? FoundRelation extends {
+    hint: string;
+} ? {
+    referencedTable: TablesAndViews<Schema>[RelatedRelationName];
+    relation: FoundRelation;
+    direction: "reverse";
+    from: CurrentTableOrView;
+} : 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;
+export type FindMatchingTableRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], value extends string> = 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> : false : false : false;
+export type FindMatchingViewRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], value extends string> = 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> : false : false : false;
+export type FindMatchingHintTableRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], hint extends string, name extends string> = 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> : false : false : false;
+export type FindMatchingHintViewRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], hint extends string, name extends string> = 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> : false : false : false;
+type IsColumnsNullable<Table extends Pick<GenericTable, "Row">, Columns extends (keyof Table["Row"])[]> = Columns extends [infer Column, ...infer Rest] ? Column extends keyof Table["Row"] ? ContainsNull<Table["Row"][Column]> extends true ? true : IsColumnsNullable<Table, Rest extends (keyof Table["Row"])[] ? Rest : []> : false : false;
+export type IsRelationNullable<Table extends GenericTable, Relation extends GenericRelationship> = IsColumnsNullable<Table, Relation["columns"]>;
+type TableForwardRelationships<Schema extends GenericSchema, TName> = TName extends keyof TablesAndViews<Schema> ? UnionToArray<RecursivelyFindRelationships<Schema, TName, keyof TablesAndViews<Schema>>> extends infer R ? R extends (GenericRelationship & {
+    from: keyof TablesAndViews<Schema>;
+})[] ? R : [] : [] : [];
+type RecursivelyFindRelationships<Schema extends GenericSchema, TName, Keys extends keyof TablesAndViews<Schema>> = Keys extends infer K ? K extends keyof TablesAndViews<Schema> ? FilterRelationships<TablesAndViews<Schema>[K]["Relationships"], TName, K> extends never ? RecursivelyFindRelationships<Schema, TName, Exclude<Keys, K>> : FilterRelationships<TablesAndViews<Schema>[K]["Relationships"], TName, K> | RecursivelyFindRelationships<Schema, TName, Exclude<Keys, K>> : false : false;
+type FilterRelationships<R, TName, From> = R extends readonly (infer Rel)[] ? Rel extends {
+    referencedRelation: TName;
+} ? Rel & {
+    from: From;
+} : never : never;
+export type ResolveForwardRelationship<Schema extends GenericSchema, Field extends Ast.FieldNode, CurrentTableOrView extends keyof TablesAndViews<Schema> & string> = FindFieldMatchingRelationships<Schema, TablesAndViews<Schema>[Field["name"]]["Relationships"], Ast.FieldNode & {
+    name: CurrentTableOrView;
+    hint: Field["hint"];
+}> 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"]}`>;
+/**
+ * Given a CurrentTableOrView, finds all join tables to this relation.
+ * For example, if products and categories are linked via product_categories table:
+ *
+ * @example
+ * Given:
+ * - CurrentTableView = 'products'
+ * - FieldName = "categories"
+ *
+ * It should return this relationship from product_categories:
+ * {
+ *   foreignKeyName: "product_categories_category_id_fkey",
+ *   columns: ["category_id"],
+ *   isOneToOne: false,
+ *   referencedRelation: "categories",
+ *   referencedColumns: ["id"]
+ * }
+ */
+type ResolveJoinTableRelationship<Schema extends GenericSchema, CurrentTableOrView extends keyof TablesAndViews<Schema> & string, FieldName extends string> = {
+    [TableName in keyof TablesAndViews<Schema>]: DeduplicateRelationships<TablesAndViews<Schema>[TableName]["Relationships"]> extends readonly (infer Rel)[] ? Rel extends {
+        referencedRelation: CurrentTableOrView;
+    } ? DeduplicateRelationships<TablesAndViews<Schema>[TableName]["Relationships"]> extends readonly (infer OtherRel)[] ? OtherRel extends {
+        referencedRelation: FieldName;
+    } ? OtherRel : never : never : never : 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.
+ */
+export type FindFieldMatchingRelationships<Schema extends GenericSchema, Relationships extends GenericRelationship[], Field extends Ast.FieldNode> = Field extends {
+    hint: string;
+} ? FindMatchingHintTableRelationships<Schema, Relationships, Field["hint"], Field["name"]> extends GenericRelationship ? FindMatchingHintTableRelationships<Schema, Relationships, Field["hint"], Field["name"]> & {
+    branch: "found-in-table-via-hint";
+    hint: Field["hint"];
+} : FindMatchingHintViewRelationships<Schema, Relationships, Field["hint"], Field["name"]> 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 GenericRelationship ? FindMatchingTableRelationships<Schema, Relationships, Field["name"]> & {
+    branch: "found-in-table-via-name";
+    name: Field["name"];
+} : FindMatchingViewRelationships<Schema, Relationships, Field["name"]> extends GenericRelationship ? FindMatchingViewRelationships<Schema, Relationships, Field["name"]> & {
+    branch: "found-in-view-via-name";
+    name: Field["name"];
+} : SelectQueryError<"Failed to find matching relation via name">;
+export type JsonPathToAccessor<Path extends string> = Path extends `${infer P1}->${infer P2}` ? P2 extends `>${infer Rest}` ? JsonPathToAccessor<`${P1}.${Rest}`> : P2 extends string ? JsonPathToAccessor<`${P1}.${P2}`> : Path : Path extends `>${infer Rest}` ? JsonPathToAccessor<Rest> : Path extends `${infer P1}::${infer _}` ? JsonPathToAccessor<P1> : Path extends `${infer P1}${")" | ","}${infer _}` ? P1 : Path;
+export type JsonPathToType<T, Path extends string> = Path extends "" ? T : ContainsNull<T> extends true ? JsonPathToType<Exclude<T, null>, Path> : Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? JsonPathToType<T[Key], Rest> : never : Path extends keyof T ? T[Path] : never;
+export type IsStringUnion<T> = string extends T ? false : T extends string ? [T] extends [never] ? false : true : false;
+type ComputedField<Schema extends GenericSchema, RelationName extends keyof TablesAndViews<Schema>, FieldName extends keyof TablesAndViews<Schema>[RelationName]["Row"]> = FieldName extends keyof Schema["Functions"] ? Schema["Functions"][FieldName] extends {
+    Args: {
+        "": TablesAndViews<Schema>[RelationName]["Row"];
+    };
+    Returns: any;
+} ? FieldName : never : never;
+export type GetComputedFields<Schema extends GenericSchema, RelationName extends keyof TablesAndViews<Schema>> = {
+    [K in keyof TablesAndViews<Schema>[RelationName]["Row"]]: ComputedField<Schema, RelationName, K>;
+}[keyof TablesAndViews<Schema>[RelationName]["Row"]];
+export {};

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

@@ -0,0 +1,109 @@
+import PostgrestError from "./PostgrestError";
+import { ContainsNull } from "./select-query-parser/types";
+import { IsAny, SelectQueryError } from "./select-query-parser/utils";
+export type Fetch = typeof fetch;
+/**
+ * Response format
+ *
+ * {@link https://github.com/supabase/supabase-js/issues/32}
+ */
+interface PostgrestResponseBase {
+    status: number;
+    statusText: string;
+}
+export interface PostgrestResponseSuccess<T> extends PostgrestResponseBase {
+    error: null;
+    data: T;
+    count: number | null;
+}
+export interface PostgrestResponseFailure extends PostgrestResponseBase {
+    error: PostgrestError;
+    data: null;
+    count: null;
+}
+export type PostgrestSingleResponse<T> = PostgrestResponseSuccess<T> | PostgrestResponseFailure;
+export type PostgrestMaybeSingleResponse<T> = PostgrestSingleResponse<T | null>;
+export type PostgrestResponse<T> = PostgrestSingleResponse<T[]>;
+export type GenericRelationship = {
+    foreignKeyName: string;
+    columns: string[];
+    isOneToOne?: boolean;
+    referencedRelation: string;
+    referencedColumns: string[];
+};
+export type GenericTable = {
+    Row: Record<string, unknown>;
+    Insert: Record<string, unknown>;
+    Update: Record<string, unknown>;
+    Relationships: GenericRelationship[];
+};
+export type GenericUpdatableView = {
+    Row: Record<string, unknown>;
+    Insert: Record<string, unknown>;
+    Update: Record<string, unknown>;
+    Relationships: GenericRelationship[];
+};
+export type GenericNonUpdatableView = {
+    Row: Record<string, unknown>;
+    Relationships: GenericRelationship[];
+};
+export type GenericView = GenericUpdatableView | GenericNonUpdatableView;
+export type GenericFunction = {
+    Args: Record<string, unknown>;
+    Returns: unknown;
+};
+export type GenericSchema = {
+    Tables: Record<string, GenericTable>;
+    Views: Record<string, GenericView>;
+    Functions: Record<string, GenericFunction>;
+};
+export type ClientServerOptions = {
+    PostgrestVersion?: string;
+};
+export type DatabaseWithOptions<Database, Options extends ClientServerOptions> = {
+    db: Database;
+    options: Options;
+};
+declare const INTERNAL_SUPABASE_OPTIONS = "__InternalSupabase";
+export type GetGenericDatabaseWithOptions<Database, Opts extends ClientServerOptions = {
+    PostgrestVersion: "12";
+}> = IsAny<Database> extends true ? DatabaseWithOptions<Database, Opts> : typeof INTERNAL_SUPABASE_OPTIONS extends keyof Database ? Database[typeof INTERNAL_SUPABASE_OPTIONS] extends ClientServerOptions ? DatabaseWithOptions<Omit<Database, typeof INTERNAL_SUPABASE_OPTIONS>, Database[typeof INTERNAL_SUPABASE_OPTIONS]> : DatabaseWithOptions<Omit<Database, typeof INTERNAL_SUPABASE_OPTIONS>, Opts> : DatabaseWithOptions<Database, Opts>;
+export type MaxAffectedEnabled<PostgrestVersion extends string | undefined> = PostgrestVersion extends `13${string}` ? true : false;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>, object>;
+type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? {
+    [TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
+} : Type;
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+type BuiltIns = Primitive | void | Date | RegExp;
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type IsValidResultOverride<Result, NewResult, ErrorResult, ErrorNewResult> = Result extends any[] ? NewResult extends any[] ? true : ErrorResult : NewResult extends any[] ? ErrorNewResult : true;
+/**
+ * Utility type to check if array types match between Result and NewResult.
+ * Returns either the valid NewResult type or an error message type.
+ */
+export type CheckMatchingArrayTypes<Result, NewResult> = Result extends SelectQueryError<string> ? NewResult : IsValidResultOverride<Result, NewResult, {
+    Error: "Type mismatch: Cannot cast array result to a single object. Use .overrideTypes<Array<YourType>> or .returns<Array<YourType>> (deprecated) for array results or .single() to convert the result to a single object";
+}, {
+    Error: "Type mismatch: Cannot cast single object to array type. Remove Array wrapper from return type or make sure you are not using .single() up in the calling chain";
+}> extends infer ValidationResult ? ValidationResult extends true ? ContainsNull<Result> extends true ? NewResult | null : NewResult : ValidationResult : never;
+type Simplify<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} : T;
+type ExplicitKeys<T> = {
+    [K in keyof T]: string extends K ? never : K;
+}[keyof T];
+type MergeExplicit<New, Row> = {
+    [K in ExplicitKeys<New> | ExplicitKeys<Row>]: K extends keyof New ? K extends keyof Row ? Row[K] extends SelectQueryError<string> ? New[K] : New[K] extends any[] ? Row[K] extends any[] ? Array<Simplify<MergeDeep<NonNullable<New[K][number]>, NonNullable<Row[K][number]>>>> : New[K] : IsPlainObject<NonNullable<New[K]>> extends true ? IsPlainObject<NonNullable<Row[K]>> extends true ? ContainsNull<New[K]> extends true ? // If the override wants to preserve optionality
+    Simplify<MergeDeep<NonNullable<New[K]>, NonNullable<Row[K]>>> | null : Simplify<MergeDeep<New[K], NonNullable<Row[K]>>> : New[K] : New[K] : New[K] : K extends keyof Row ? Row[K] : never;
+};
+type MergeDeep<New, Row> = Simplify<MergeExplicit<New, Row> & (string extends keyof Row ? {
+    [K: string]: Row[string];
+} : {})>;
+type IsPlainObject<T> = T extends any[] ? false : T extends object ? true : false;
+export type MergePartialResult<NewResult, Result, Options> = Options extends {
+    merge: true;
+} ? Result extends any[] ? NewResult extends any[] ? Array<Simplify<MergeDeep<NewResult[number], Result[number]>>> : never : Simplify<MergeDeep<NewResult, Result>> : NewResult;
+export {};

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

@@ -0,0 +1 @@
+export declare const version = "0.0.0-automated";

package/lib/index.d.ts

@@ -1,16 +1,28 @@
-import { CloudBaseInstance, ExtendedCloudBaseInstance, OrmClient } from './types';
+import { CloudBaseInstance, ExtendedCloudBaseInstance, IMySqlOptions, OrmClient } from './types';
 import { generateHTTPClient } from './orm/http-orm-client';
+import { MySqlClient } from './db/mysql';
+import { Fetch } from './db/postgrest/types';
 export declare function initHTTPOverCallFunction(cloud: CloudBaseInstance, options?: {
+    envId?: string;
     baseUrl?: string;
     sqlBaseUrl?: string;
+    mysqlBaseUrl?: string;
 }): ExtendedCloudBaseInstance;
-export declare function init(cloud: CloudBaseInstance): ExtendedCloudBaseInstance;
+export declare function init(cloud: CloudBaseInstance, options?: {
+    envId?: string;
+}): ExtendedCloudBaseInstance;
+declare function generateMySQLClient(cloud: CloudBaseInstance, options?: {
+    envId?: string;
+    mysqlBaseUrl?: string;
+    fetch?: Fetch;
+}): (options?: IMySqlOptions) => MySqlClient<any, {}>;
 export * from './types';
-export { generateHTTPClient };
+export { generateHTTPClient, generateMySQLClient };
 declare const _default: {
     init: typeof init;
     generateHTTPClient: (callFunction: import("./types").CallFunction, fetch: (options: import("@cloudbase/adapter-interface").IFetchOptions) => any, baseUrl: string, options?: {
         sqlBaseUrl?: string | undefined;
     } | undefined) => OrmClient;
+    generateMySQLClient: typeof generateMySQLClient;
 };
 export default _default;

package/lib/types/index.d.ts

@@ -1,4 +1,5 @@
 import { SDKRequestInterface } from '@cloudbase/adapter-interface';
+import { MySqlClient } from '../db/mysql';
 /**
  * 基础 Model 类型定义
  */
@@ -709,12 +710,14 @@ export type CloudBaseInstance = {
     callFunction: CallFunction;
     auth: any;
 };
+export type IMySqlClient = (options?: IMySqlOptions) => MySqlClient;
 /**
  * 扩展的云实例接口，扩展了云函数调用接口并包含ORM客户端。
  * @hidden
  */
 export interface ExtendedCloudBaseInstance extends CloudBaseInstance {
     models: OrmClient & OrmRawQueryClient;
+    mysql: IMySqlClient;
 }
 /**
  * 云函数调用方法定义。
@@ -727,4 +730,8 @@ export type CallFunction = (args: {
     data: Record<string, any>;
 }) => Promise<any>;
 export type ModelFetch = NonNullable<SDKRequestInterface['fetch']>;
+export interface IMySqlOptions {
+    instance?: string;
+    database?: string;
+}
 export {};