tokentracker-cli 0.5.0 → 0.5.2

package/node_modules/@supabase/postgrest-js/src/PostgrestBuilder.ts

@@ -1,300 +0,0 @@
-// @ts-ignore
-import nodeFetch from '@supabase/node-fetch'
-
-import type {
-  Fetch,
-  PostgrestSingleResponse,
-  PostgrestResponseSuccess,
-  CheckMatchingArrayTypes,
-  MergePartialResult,
-  IsValidResultOverride,
-  ClientServerOptions,
-} from './types'
-import PostgrestError from './PostgrestError'
-import { ContainsNull } from './select-query-parser/types'
-
-export default abstract class PostgrestBuilder<
-  ClientOptions extends ClientServerOptions,
-  Result,
-  ThrowOnError extends boolean = false
-> implements
-    PromiseLike<
-      ThrowOnError extends true ? PostgrestResponseSuccess<Result> : PostgrestSingleResponse<Result>
-    >
-{
-  protected method: 'GET' | 'HEAD' | 'POST' | 'PATCH' | 'DELETE'
-  protected url: URL
-  protected headers: Headers
-  protected schema?: string
-  protected body?: unknown
-  protected shouldThrowOnError = false
-  protected signal?: AbortSignal
-  protected fetch: Fetch
-  protected isMaybeSingle: boolean
-
-  constructor(builder: {
-    method: 'GET' | 'HEAD' | 'POST' | 'PATCH' | 'DELETE'
-    url: URL
-    headers: HeadersInit
-    schema?: string
-    body?: unknown
-    shouldThrowOnError?: boolean
-    signal?: AbortSignal
-    fetch?: Fetch
-    isMaybeSingle?: boolean
-  }) {
-    this.method = builder.method
-    this.url = builder.url
-    this.headers = new Headers(builder.headers)
-    this.schema = builder.schema
-    this.body = builder.body
-    this.shouldThrowOnError = builder.shouldThrowOnError ?? false
-    this.signal = builder.signal
-    this.isMaybeSingle = builder.isMaybeSingle ?? false
-
-    if (builder.fetch) {
-      this.fetch = builder.fetch
-    } else if (typeof fetch === 'undefined') {
-      this.fetch = nodeFetch
-    } else {
-      this.fetch = fetch
-    }
-  }
-
-  /**
-   * If there's an error with the query, throwOnError will reject the promise by
-   * throwing the error instead of returning it as part of a successful response.
-   *
-   * {@link https://github.com/supabase/supabase-js/issues/92}
-   */
-  throwOnError(): this & PostgrestBuilder<ClientOptions, Result, true> {
-    this.shouldThrowOnError = true
-    return this as this & PostgrestBuilder<ClientOptions, Result, true>
-  }
-
-  /**
-   * Set an HTTP header for the request.
-   */
-  setHeader(name: string, value: string): this {
-    this.headers = new Headers(this.headers)
-    this.headers.set(name, value)
-    return this
-  }
-
-  then<
-    TResult1 = ThrowOnError extends true
-      ? PostgrestResponseSuccess<Result>
-      : PostgrestSingleResponse<Result>,
-    TResult2 = never
-  >(
-    onfulfilled?:
-      | ((
-          value: ThrowOnError extends true
-            ? PostgrestResponseSuccess<Result>
-            : PostgrestSingleResponse<Result>
-        ) => TResult1 | PromiseLike<TResult1>)
-      | undefined
-      | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
-  ): PromiseLike<TResult1 | TResult2> {
-    // https://postgrest.org/en/stable/api.html#switching-schemas
-    if (this.schema === undefined) {
-      // skip
-    } else if (['GET', 'HEAD'].includes(this.method)) {
-      this.headers.set('Accept-Profile', this.schema)
-    } else {
-      this.headers.set('Content-Profile', this.schema)
-    }
-    if (this.method !== 'GET' && this.method !== 'HEAD') {
-      this.headers.set('Content-Type', 'application/json')
-    }
-
-    // NOTE: Invoke w/o `this` to avoid illegal invocation error.
-    // https://github.com/supabase/postgrest-js/pull/247
-    const _fetch = this.fetch
-    let res = _fetch(this.url.toString(), {
-      method: this.method,
-      headers: this.headers,
-      body: JSON.stringify(this.body),
-      signal: this.signal,
-    }).then(async (res) => {
-      let error = null
-      let data = null
-      let count: number | null = null
-      let status = res.status
-      let statusText = res.statusText
-
-      if (res.ok) {
-        if (this.method !== 'HEAD') {
-          const body = await res.text()
-          if (body === '') {
-            // Prefer: return=minimal
-          } else if (this.headers.get('Accept') === 'text/csv') {
-            data = body
-          } else if (
-            this.headers.get('Accept') &&
-            this.headers.get('Accept')?.includes('application/vnd.pgrst.plan+text')
-          ) {
-            data = body
-          } else {
-            data = JSON.parse(body)
-          }
-        }
-
-        const countHeader = this.headers.get('Prefer')?.match(/count=(exact|planned|estimated)/)
-        const contentRange = res.headers.get('content-range')?.split('/')
-        if (countHeader && contentRange && contentRange.length > 1) {
-          count = parseInt(contentRange[1])
-        }
-
-        // Temporary partial fix for https://github.com/supabase/postgrest-js/issues/361
-        // Issue persists e.g. for `.insert([...]).select().maybeSingle()`
-        if (this.isMaybeSingle && this.method === 'GET' && Array.isArray(data)) {
-          if (data.length > 1) {
-            error = {
-              // https://github.com/PostgREST/postgrest/blob/a867d79c42419af16c18c3fb019eba8df992626f/src/PostgREST/Error.hs#L553
-              code: 'PGRST116',
-              details: `Results contain ${data.length} rows, application/vnd.pgrst.object+json requires 1 row`,
-              hint: null,
-              message: 'JSON object requested, multiple (or no) rows returned',
-            }
-            data = null
-            count = null
-            status = 406
-            statusText = 'Not Acceptable'
-          } else if (data.length === 1) {
-            data = data[0]
-          } else {
-            data = null
-          }
-        }
-      } else {
-        const body = await res.text()
-
-        try {
-          error = JSON.parse(body)
-
-          // Workaround for https://github.com/supabase/postgrest-js/issues/295
-          if (Array.isArray(error) && res.status === 404) {
-            data = []
-            error = null
-            status = 200
-            statusText = 'OK'
-          }
-        } catch {
-          // Workaround for https://github.com/supabase/postgrest-js/issues/295
-          if (res.status === 404 && body === '') {
-            status = 204
-            statusText = 'No Content'
-          } else {
-            error = {
-              message: body,
-            }
-          }
-        }
-
-        if (error && this.isMaybeSingle && error?.details?.includes('0 rows')) {
-          error = null
-          status = 200
-          statusText = 'OK'
-        }
-
-        if (error && this.shouldThrowOnError) {
-          throw new PostgrestError(error)
-        }
-      }
-
-      const postgrestResponse = {
-        error,
-        data,
-        count,
-        status,
-        statusText,
-      }
-
-      return postgrestResponse
-    })
-    if (!this.shouldThrowOnError) {
-      res = res.catch((fetchError) => ({
-        error: {
-          message: `${fetchError?.name ?? 'FetchError'}: ${fetchError?.message}`,
-          details: `${fetchError?.stack ?? ''}`,
-          hint: '',
-          code: `${fetchError?.code ?? ''}`,
-        },
-        data: null,
-        count: null,
-        status: 0,
-        statusText: '',
-      }))
-    }
-
-    return res.then(onfulfilled, onrejected)
-  }
-
-  /**
-   * 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>(): PostgrestBuilder<
-    ClientOptions,
-    CheckMatchingArrayTypes<Result, NewResult>,
-    ThrowOnError
-  > {
-    /* istanbul ignore next */
-    return this as unknown as PostgrestBuilder<
-      ClientOptions,
-      CheckMatchingArrayTypes<Result, NewResult>,
-      ThrowOnError
-    >
-  }
-
-  /**
-   * Override the type of the returned `data` field in the response.
-   *
-   * @typeParam NewResult - The new type to cast the response data to
-   * @typeParam Options - Optional type configuration (defaults to { merge: true })
-   * @typeParam Options.merge - When true, merges the new type with existing return type. When false, replaces the existing types entirely (defaults to true)
-   * @example
-   * ```typescript
-   * // Merge with existing types (default behavior)
-   * const query = supabase
-   *   .from('users')
-   *   .select()
-   *   .overrideTypes<{ custom_field: string }>()
-   *
-   * // Replace existing types completely
-   * const replaceQuery = supabase
-   *   .from('users')
-   *   .select()
-   *   .overrideTypes<{ id: number; name: string }, { merge: false }>()
-   * ```
-   * @returns A PostgrestBuilder instance with the new type
-   */
-  overrideTypes<
-    NewResult,
-    Options extends { merge?: boolean } = { merge: true }
-  >(): PostgrestBuilder<
-    ClientOptions,
-    IsValidResultOverride<Result, NewResult, false, false> extends true
-      ? // Preserve the optionality of the result if the overriden type is an object (case of chaining with `maybeSingle`)
-        ContainsNull<Result> extends true
-        ? MergePartialResult<NewResult, NonNullable<Result>, Options> | null
-        : MergePartialResult<NewResult, Result, Options>
-      : CheckMatchingArrayTypes<Result, NewResult>,
-    ThrowOnError
-  > {
-    return this as unknown as PostgrestBuilder<
-      ClientOptions,
-      IsValidResultOverride<Result, NewResult, false, false> extends true
-        ? // Preserve the optionality of the result if the overriden type is an object (case of chaining with `maybeSingle`)
-          ContainsNull<Result> extends true
-          ? MergePartialResult<NewResult, NonNullable<Result>, Options> | null
-          : MergePartialResult<NewResult, Result, Options>
-        : CheckMatchingArrayTypes<Result, NewResult>,
-      ThrowOnError
-    >
-  }
-}

package/node_modules/@supabase/postgrest-js/src/PostgrestClient.ts

@@ -1,192 +0,0 @@
-import PostgrestQueryBuilder from './PostgrestQueryBuilder'
-import PostgrestFilterBuilder from './PostgrestFilterBuilder'
-import { Fetch, GenericSchema, ClientServerOptions } from './types'
-
-/**
- * PostgREST client.
- *
- * @typeParam Database - Types for the schema from the [type
- * generator](https://supabase.com/docs/reference/javascript/next/typescript-support)
- *
- * @typeParam SchemaName - Postgres schema to switch to. Must be a string
- * literal, the same one passed to the constructor. If the schema is not
- * `"public"`, this must be supplied manually.
- */
-export default class PostgrestClient<
-  Database = any,
-  ClientOptions extends ClientServerOptions = Database extends {
-    __InternalSupabase: infer I extends ClientServerOptions
-  }
-    ? I
-    : {},
-  SchemaName extends string &
-    keyof Omit<Database, '__InternalSupabase'> = 'public' extends keyof Omit<
-    Database,
-    '__InternalSupabase'
-  >
-    ? 'public'
-    : string & keyof Omit<Database, '__InternalSupabase'>,
-  Schema extends GenericSchema = Omit<
-    Database,
-    '__InternalSupabase'
-  >[SchemaName] extends GenericSchema
-    ? Omit<Database, '__InternalSupabase'>[SchemaName]
-    : any
-> {
-  url: string
-  headers: Headers
-  schemaName?: SchemaName
-  fetch?: Fetch
-
-  // TODO: Add back shouldThrowOnError once we figure out the typings
-  /**
-   * Creates a PostgREST client.
-   *
-   * @param url - URL of the PostgREST endpoint
-   * @param options - Named parameters
-   * @param options.headers - Custom headers
-   * @param options.schema - Postgres schema to switch to
-   * @param options.fetch - Custom fetch
-   */
-  constructor(
-    url: string,
-    {
-      headers = {},
-      schema,
-      fetch,
-    }: {
-      headers?: HeadersInit
-      schema?: SchemaName
-      fetch?: Fetch
-    } = {}
-  ) {
-    this.url = url
-    this.headers = new Headers(headers)
-    this.schemaName = schema
-    this.fetch = fetch
-  }
-  from<
-    TableName extends string & keyof Schema['Tables'],
-    Table extends Schema['Tables'][TableName]
-  >(relation: TableName): PostgrestQueryBuilder<ClientOptions, Schema, Table, TableName>
-  from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(
-    relation: ViewName
-  ): PostgrestQueryBuilder<ClientOptions, Schema, View, ViewName>
-  /**
-   * Perform a query on a table or a view.
-   *
-   * @param relation - The table or view name to query
-   */
-  from(relation: string): PostgrestQueryBuilder<ClientOptions, Schema, any, any> {
-    const url = new URL(`${this.url}/${relation}`)
-    return new PostgrestQueryBuilder(url, {
-      headers: new Headers(this.headers),
-      schema: this.schemaName,
-      fetch: this.fetch,
-    })
-  }
-
-  /**
-   * Select a schema to query or perform an function (rpc) call.
-   *
-   * The schema needs to be on the list of exposed schemas inside Supabase.
-   *
-   * @param schema - The schema to query
-   */
-  schema<DynamicSchema extends string & keyof Omit<Database, '__InternalSupabase'>>(
-    schema: DynamicSchema
-  ): PostgrestClient<
-    Database,
-    ClientOptions,
-    DynamicSchema,
-    Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any
-  > {
-    return new PostgrestClient(this.url, {
-      headers: this.headers,
-      schema,
-      fetch: this.fetch,
-    })
-  }
-
-  /**
-   * Perform a function call.
-   *
-   * @param fn - The function name to call
-   * @param args - The arguments to pass to the function call
-   * @param options - Named parameters
-   * @param options.head - When set to `true`, `data` will not be returned.
-   * Useful if you only need the count.
-   * @param options.get - When set to `true`, the function will be called with
-   * read-only access mode.
-   * @param options.count - Count algorithm to use to count rows returned by the
-   * function. Only applicable for [set-returning
-   * functions](https://www.postgresql.org/docs/current/functions-srf.html).
-   *
-   * `"exact"`: Exact but slow count algorithm. Performs a `COUNT(*)` under the
-   * hood.
-   *
-   * `"planned"`: Approximated but fast count algorithm. Uses the Postgres
-   * statistics under the hood.
-   *
-   * `"estimated"`: Uses exact count for low numbers and planned count for high
-   * numbers.
-   */
-  rpc<FnName extends string & keyof Schema['Functions'], Fn extends Schema['Functions'][FnName]>(
-    fn: FnName,
-    args: Fn['Args'] = {},
-    {
-      head = false,
-      get = false,
-      count,
-    }: {
-      head?: boolean
-      get?: boolean
-      count?: 'exact' | 'planned' | 'estimated'
-    } = {}
-  ): PostgrestFilterBuilder<
-    ClientOptions,
-    Schema,
-    Fn['Returns'] extends any[]
-      ? Fn['Returns'][number] extends Record<string, unknown>
-        ? Fn['Returns'][number]
-        : never
-      : never,
-    Fn['Returns'],
-    FnName,
-    null,
-    'RPC'
-  > {
-    let method: 'HEAD' | 'GET' | 'POST'
-    const url = new URL(`${this.url}/rpc/${fn}`)
-    let body: unknown | undefined
-    if (head || get) {
-      method = head ? 'HEAD' : 'GET'
-      Object.entries(args)
-        // params with undefined value needs to be filtered out, otherwise it'll
-        // show up as `?param=undefined`
-        .filter(([_, value]) => value !== undefined)
-        // array values need special syntax
-        .map(([name, value]) => [name, Array.isArray(value) ? `{${value.join(',')}}` : `${value}`])
-        .forEach(([name, value]) => {
-          url.searchParams.append(name, value)
-        })
-    } else {
-      method = 'POST'
-      body = args
-    }
-
-    const headers = new Headers(this.headers)
-    if (count) {
-      headers.set('Prefer', `count=${count}`)
-    }
-
-    return new PostgrestFilterBuilder({
-      method,
-      url,
-      headers,
-      schema: this.schemaName,
-      body,
-      fetch: this.fetch ?? fetch,
-    })
-  }
-}

package/node_modules/@supabase/postgrest-js/src/PostgrestError.ts

@@ -1,18 +0,0 @@
-/**
- * Error format
- *
- * {@link https://postgrest.org/en/stable/api.html?highlight=options#errors-and-http-status-codes}
- */
-export default class PostgrestError extends Error {
-  details: string
-  hint: string
-  code: string
-
-  constructor(context: { message: string; details: string; hint: string; code: string }) {
-    super(context.message)
-    this.name = 'PostgrestError'
-    this.details = context.details
-    this.hint = context.hint
-    this.code = context.code
-  }
-}