@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/db/src/index.ts

@@ -1,2 +0,0 @@
-export { DatabaseService } from './DatabaseService'
-export { QueryBuilder } from './QueryBuilder'

package/packages/db/src/pgrst-types/common/common.ts

@@ -1,86 +0,0 @@
-// Vendored from @supabase/postgrest-js (MIT, Copyright (c) Supabase).
-// Provenance précise (version amont, SHA, procédure de resync) : voir packages/db/VENDORED.md
-// Adapté pour aurabase — ne pas modifier la logique du parser/résolveur.
-// Types that are shared between supabase-js and postgrest-js
-
-export type Fetch = typeof fetch
-
-/**
- * Default number of retry attempts.
- */
-export const DEFAULT_MAX_RETRIES = 3
-
-/**
- * Default exponential backoff delay function.
- * Delays: 1s, 2s, 4s, 8s, ... (max 30s)
- *
- * @param attemptIndex - Zero-based index of the retry attempt
- * @returns Delay in milliseconds before the next retry
- */
-export const getRetryDelay = (attemptIndex: number): number =>
-  Math.min(1000 * 2 ** attemptIndex, 30000)
-
-/**
- * Status codes that are safe to retry.
- * 520 = Cloudflare timeout/connection errors (transient)
- * 503 = PostgREST schema cache not yet loaded (transient, signals retry via Retry-After header)
- */
-export const RETRYABLE_STATUS_CODES = [520, 503] as const
-
-/**
- * HTTP methods that are safe to retry (idempotent operations).
- */
-export const RETRYABLE_METHODS = ['GET', 'HEAD', 'OPTIONS'] as const
-
-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 GenericSetofOption = {
-  isSetofReturn?: boolean | undefined
-  isOneToOne?: boolean | undefined
-  isNotNullable?: boolean | undefined
-  to: string
-  from: string
-}
-
-export type GenericFunction = {
-  Args: Record<string, unknown> | never
-  Returns: unknown
-  SetofOptions?: GenericSetofOption
-}
-
-export type GenericSchema = {
-  Tables: Record<string, GenericTable>
-  Views: Record<string, GenericView>
-  Functions: Record<string, GenericFunction>
-}
-
-export type ClientServerOptions = {
-  PostgrestVersion?: string
-}

package/packages/db/src/pgrst-types/common/rpc.ts

@@ -1,151 +0,0 @@
-// Vendored from @supabase/postgrest-js (MIT, Copyright (c) Supabase).
-// Provenance précise (version amont, SHA, procédure de resync) : voir packages/db/VENDORED.md
-// Adapté pour aurabase — ne pas modifier la logique du parser/résolveur.
-import type { GenericFunction, GenericSchema, GenericSetofOption } from './common'
-
-// Functions matching utils
-type IsMatchingArgs<
-  FnArgs extends GenericFunction['Args'],
-  PassedArgs extends GenericFunction['Args'],
-> = [FnArgs] extends [Record<PropertyKey, never>]
-  ? PassedArgs extends Record<PropertyKey, never>
-    ? true
-    : false
-  : keyof PassedArgs extends keyof FnArgs
-    ? PassedArgs extends FnArgs
-      ? true
-      : false
-    : false
-
-type MatchingFunctionArgs<
-  Fn extends GenericFunction,
-  Args extends GenericFunction['Args'],
-> = Fn extends { Args: infer A extends GenericFunction['Args'] }
-  ? IsMatchingArgs<A, Args> extends true
-    ? Fn
-    : never
-  : false
-
-type FindMatchingFunctionByArgs<
-  FnUnion,
-  Args extends GenericFunction['Args'],
-> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false
-
-// Types for working with database schemas
-type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>
-
-// Utility types for working with unions
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
-  ? I
-  : never
-
-type LastOf<T> =
-  UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never
-
-type IsAny<T> = 0 extends 1 & T ? true : false
-
-type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false
-
-type ExtractExactFunction<Fns, Args> = Fns extends infer F
-  ? F extends GenericFunction
-    ? ExactMatch<F['Args'], Args> extends true
-      ? F
-      : never
-    : never
-  : never
-
-type IsNever<T> = [T] extends [never] ? true : false
-
-type RpcFunctionNotFound<FnName> = {
-  Row: any
-  Result: {
-    error: true
-  } & "Couldn't infer function definition matching provided arguments"
-  RelationName: FnName
-  Relationships: null
-}
-
-type CrossSchemaError<TableRef extends string> = {
-  error: true
-} & `Function returns SETOF from a different schema ('${TableRef}'). Use .overrideTypes<YourReturnType>() to specify the return type explicitly.`
-
-export type GetRpcFunctionFilterBuilderByArgs<
-  Schema extends GenericSchema,
-  FnName extends string & keyof Schema['Functions'],
-  Args,
-> = {
-  0: Schema['Functions'][FnName]
-  // If the Args is exactly never (function call without any params)
-  1: IsAny<Schema> extends true
-    ? any
-    : IsNever<Args> extends true
-      ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
-        // we fallback to the last function definition matched by name
-        IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true
-        ? LastOf<Schema['Functions'][FnName]>
-        : ExtractExactFunction<Schema['Functions'][FnName], Args>
-      : Args extends Record<PropertyKey, never>
-        ? LastOf<Schema['Functions'][FnName]>
-        : // Otherwise, we attempt to match with one of the function definition in the union based
-          // on the function arguments provided
-          Args extends GenericFunction['Args']
-          ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
-            // we fallback to the last function definition matched by name
-            IsNever<
-              LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
-            > extends true
-            ? LastOf<Schema['Functions'][FnName]>
-            : // Otherwise, we use the arguments based function definition narrowing to get the right value
-              LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
-          : // If we can't find a matching function by args, we try to find one by function name
-            ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction
-            ? ExtractExactFunction<Schema['Functions'][FnName], Args>
-            : any
-}[1] extends infer Fn
-  ? // If we are dealing with an non-typed client everything is any
-    IsAny<Fn> extends true
-    ? { Row: any; Result: any; RelationName: FnName; Relationships: null }
-    : // Otherwise, we use the arguments based function definition narrowing to get the right value
-      Fn extends GenericFunction
-      ? {
-          Row: Fn['SetofOptions'] extends GenericSetofOption
-            ? Fn['SetofOptions']['to'] extends keyof TablesAndViews<Schema>
-              ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row']
-              : // Cross-schema fallback: use Returns type when table is not in current schema
-                Fn['Returns'] extends any[]
-                ? Fn['Returns'][number] extends Record<string, unknown>
-                  ? Fn['Returns'][number]
-                  : CrossSchemaError<Fn['SetofOptions']['to'] & string>
-                : Fn['Returns'] extends Record<string, unknown>
-                  ? Fn['Returns']
-                  : CrossSchemaError<Fn['SetofOptions']['to'] & string>
-            : Fn['Returns'] extends any[]
-              ? Fn['Returns'][number] extends Record<string, unknown>
-                ? Fn['Returns'][number]
-                : never
-              : Fn['Returns'] extends Record<string, unknown>
-                ? Fn['Returns']
-                : never
-          Result: Fn['SetofOptions'] extends GenericSetofOption
-            ? Fn['SetofOptions']['isSetofReturn'] extends true
-              ? Fn['SetofOptions']['isOneToOne'] extends true
-                ? Fn['Returns'][]
-                : Fn['Returns']
-              : Fn['Returns']
-            : Fn['Returns']
-          RelationName: Fn['SetofOptions'] extends GenericSetofOption
-            ? Fn['SetofOptions']['to']
-            : FnName
-          Relationships: Fn['SetofOptions'] extends GenericSetofOption
-            ? Fn['SetofOptions']['to'] extends keyof Schema['Tables']
-              ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships']
-              : Fn['SetofOptions']['to'] extends keyof Schema['Views']
-                ? Schema['Views'][Fn['SetofOptions']['to']]['Relationships']
-                : null
-            : null
-        }
-      : // If we failed to find the function by argument, we still pass with any but also add an overridable
-        Fn extends false
-        ? RpcFunctionNotFound<FnName>
-        : RpcFunctionNotFound<FnName>
-  : RpcFunctionNotFound<FnName>

package/packages/db/src/pgrst-types/feature-flags.ts

@@ -1,20 +0,0 @@
-// Vendored from @supabase/postgrest-js (MIT, Copyright (c) Supabase).
-// Provenance précise (version amont, SHA, procédure de resync) : voir packages/db/VENDORED.md
-// Adapté pour aurabase — ne pas modifier la logique du parser/résolveur.
-type IsPostgrest13<PostgrestVersion extends string | undefined> =
-  PostgrestVersion extends `13${string}` ? true : false
-type IsPostgrest14<PostgrestVersion extends string | undefined> =
-  PostgrestVersion extends `14${string}` ? true : false
-
-type IsPostgrestVersionGreaterThan12<PostgrestVersion extends string | undefined> =
-  IsPostgrest13<PostgrestVersion> extends true
-    ? true
-    : IsPostgrest14<PostgrestVersion> extends true
-      ? true
-      : false
-
-export type MaxAffectedEnabled<PostgrestVersion extends string | undefined> =
-  IsPostgrestVersionGreaterThan12<PostgrestVersion> extends true ? true : false
-
-export type SpreadOnManyEnabled<PostgrestVersion extends string | undefined> =
-  IsPostgrestVersionGreaterThan12<PostgrestVersion> extends true ? true : false

package/packages/db/src/pgrst-types/types.ts

@@ -1,134 +0,0 @@
-// Vendored from @supabase/postgrest-js (MIT, Copyright (c) Supabase).
-// Provenance précise (version amont, SHA, procédure de resync) : voir packages/db/VENDORED.md
-// Adapté pour aurabase — ne pas modifier la logique du parser/résolveur.
-import { ContainsNull } from '../select-query-parser/types'
-import { SelectQueryError } from '../select-query-parser/utils'
-import { ClientServerOptions } from './common/common'
-
-export type DatabaseWithOptions<Database, Options extends ClientServerOptions> = {
-  db: Database
-  options: Options
-}
-
-// https://twitter.com/mattpocockuk/status/1622730173446557697
-export type Prettify<T> = { [K in keyof T]: T[K] } & {}
-
-// Rejects excess properties that aren't in Base.
-// Works around TypeScript not checking excess properties on generic parameters.
-export type RejectExcessProperties<Base, Row> = Row & {
-  [K in Exclude<keyof Row, keyof Base>]: never
-}
-
-// https://github.com/sindresorhus/type-fest
-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[]
-      ? // Both are arrays - valid
-        true
-      : ErrorResult
-    : NewResult extends any[]
-      ? ErrorNewResult
-      : // Neither are arrays - valid
-        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> =
-  // If the result is a QueryError we allow the user to override anyway
-  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
-        ? // Preserve the optionality of the result if the overriden type is an object (case of chaining with `maybeSingle`)
-          ContainsNull<Result> extends true
-          ? NewResult | null
-          : NewResult
-        : // contains the error
-          ValidationResult
-      : never
-
-type Simplify<T> = T extends object ? { [K in keyof T]: T[K] } : T
-
-// Extract only explicit (non-index-signature) keys.
-type ExplicitKeys<T> = {
-  [K in keyof T]: string extends K ? never : K
-}[keyof T]
-
-type MergeExplicit<New, Row> = {
-  // We merge all the explicit keys which allows merge and override of types like
-  // { [key: string]: unknown } and { someSpecificKey: boolean }
-  [K in ExplicitKeys<New> | ExplicitKeys<Row>]: K extends keyof New
-    ? K extends keyof Row
-      ? Row[K] extends SelectQueryError<string>
-        ? New[K]
-        : // Check if the override is on a embedded relation (array)
-          New[K] extends any[]
-          ? Row[K] extends any[]
-            ? Array<Simplify<MergeDeep<NonNullable<New[K][number]>, NonNullable<Row[K][number]>>>>
-            : New[K]
-          : // Check if both properties are objects omitting a potential null union
-            IsPlainObject<NonNullable<New[K]>> extends true
-            ? IsPlainObject<NonNullable<Row[K]>> extends true
-              ? // If they are, use the new override as source of truth for the optionality
-                ContainsNull<New[K]> extends true
-                ? // If the override wants to preserve optionality
-                  Simplify<MergeDeep<NonNullable<New[K]>, NonNullable<Row[K]>>> | null
-                : // If the override wants to enforce non-null result
-                  Simplify<MergeDeep<New[K], NonNullable<Row[K]>>>
-              : New[K] // Override with New type if Row isn't an object
-            : New[K] // Override primitives with New type
-      : New[K] // Add new properties from New
-    : K extends keyof Row
-      ? Row[K] // Keep existing properties not in New
-      : never
-}
-
-type MergeDeep<New, Row> = Simplify<
-  MergeExplicit<New, Row> &
-    // Intersection here is to restore dynamic keys into the merging result
-    // eg:
-    // {[key: number]: string}
-    // or Record<string, number | null>
-    (string extends keyof Row ? { [K: string]: Row[string] } : {})
->
-
-// Helper to check if a type is a plain object (not an array)
-type IsPlainObject<T> = T extends any[] ? false : T extends object ? true : false
-
-// Merge the new result with the original (Result) when merge option is true.
-// If NewResult is an array, merge each element.
-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