Class CodaAPI

Hierarchy (view full)

Constructors

constructor

Properties

accessToken apiKey authPopup clientId data options permissions rawData ready ref source user _all api apiDomain authProvider capabilities defaultFormat defaultPermissions hooks phrases urls

Accessors

all authProviderServices host oAuthParams title tokenKey

Methods

#getFormat _getRef activeLogin deleteLocalUserInfo equals get getUser getUserIfValid isAuthenticated load login logout parse passiveLogin put remove request store storeLocalUserInfo stringify syncWith toString update updatePermissions upload find from getOAuthBackend load parseURL phrase register test

Constructors

constructor

Properties

accessToken

accessToken: any

apiKey

apiKey: any

authPopup

authPopup: Window

clientId

clientId: any

data

data: any

options

options: any

permissions

permissions: any

rawData

rawData: string

ready

ready: Promise<void>

ref

ref: any

source

source: string

user

user: any

Static _all

_all: any[] = []

Static api

api: {
    user: {
        fields: {
            avatar: string;
            email: string;
            name: string;
            url: (() => string);
            username: string;
        };
        get: string;
    };
} = ...

Type declaration

  • user: {
        fields: {
            avatar: string;
            email: string;
            name: string;
            url: (() => string);
            username: string;
        };
        get: string;
    }
    • fields: {
          avatar: string;
          email: string;
          name: string;
          url: (() => string);
          username: string;
      }
      • avatar: string
      • email: string
      • name: string
      • url: (() => string)
          • (): string

          • Returns string

      • username: string
    • get: string

Static apiDomain

apiDomain: string = "https://coda.io/apis/v1/"

Static authProvider

authProvider: string = "https://auth.madata.dev"

Auth Provider to use. This is only relevant for OAuthBackend, but specifying here as Backend is the only class users import.

Static capabilities

capabilities: {
    auth: boolean;
} = ...

Type declaration

  • auth: boolean

Static defaultFormat

defaultFormat: string = "JSON"

Static defaultPermissions

defaultPermissions: {
    read: boolean;
} = ...

Type declaration

  • read: boolean

Static hooks

hooks: Hooks = hooks

Static phrases

phrases: {
    login_prompt: string;
} = ...

Type declaration

  • login_prompt: string

Static urls

urls: string[] = ...

Accessors

Static all

Static authProviderServices

  • get authProviderServices(): Promise<any>

  • services.json from the auth provider will be cached here. You could also set this manually to avoid the network request.

    Returns Promise<any>

    Member

Static host

  • get host(): any

  • Return the hostname of the first URL pattern in the urls array, if not variable. This is used to facilitate relative URLs when constructing Backends directly. Subclasses with variable hostnames can override this.

    Returns any

Static oAuthParams

Static title

  • get title(): string

  • Returns string

Static tokenKey

Methods

Private #getFormat

_getRef

activeLogin

  • activeLogin(): Promise<void>
  • Abstract

    Show authentication UI to the user. Must be implemented by subclasses.

    Returns Promise<void>

deleteLocalUserInfo

equals

get

  • get(ref?): Promise<any>

  • Low-level method to fetch data from the backend. Subclasses should override this method. Clients should not call this method directly, but use load() instead.

    Parameters

    • ref: any = ...

      reference to data to fetch, if different from that provided in the constructor

    Returns Promise<any>

    • Data from the backend as a string, null if not found

getUser

  • getUser(): Promise<any>

  • Get info about the current user, if logged in. Subclasses are generally expected to override this.

    Returns Promise<any>

    • User info

getUserIfValid

isAuthenticated

  • isAuthenticated(): boolean

  • Is current user authenticated? Synchronous because it must not trigger any API calls, use passiveLogin() for that

    Returns boolean

load

  • load(url, ...args): any

  • Higher-level method for reading data from the backend. Subclasses should usually NOT override this method.

    Parameters

    • url: string

      URL to fetch, if different from that provided in the constructor

    • Rest ...args: any[]

    Returns any

    • Data from the backend as a JSON object, null if not found

login

  • login(options?): Promise<any>

  • Helper method for authenticating in OAuth APIs

    Parameters

    • Optional options: {
          passive: boolean;
      } = {}

      {object}

      • passive: boolean

        {boolean} - Do not trigger any login UI, just return the current user if already logged in

    Returns Promise<any>

logout

parse

  • parse(data, __namedParameters?): Promise<any>

  • Parameters

    • data: any
    • __namedParameters: {
          ref: any;
      } = {}
      • ref: any

    Returns Promise<any>

passiveLogin

  • passiveLogin(): Promise<void>
  • Abstract

    Try to authenticate a previously authenticated user (i.e. without showing any login UI).

    Returns Promise<void>

put

  • put(data, options): Promise<void>

  • Parameters

    • data: any
    • options: any

    Returns Promise<void>

remove

request

  • request(call, data?, method?, req?): Promise<any>

  • Helper for making OAuth requests with JSON-based APIs.

    Parameters

    • call: string

      API endpoint

    • Optional data: any

      Data to send with the request

    • Optional method: string = "GET"

      HTTP method

    • Optional req: {
          headers: any;
          responseType: string;
      }

      Extra request options

      • headers: any

        Extra headers

      • responseType: string

        Response type

    Returns Promise<any>

    • JSON response

store

  • store(data, o?): any

  • Higher-level method for writing data to the backend. Subclasses should usually NOT override this method.

    Parameters

    • data: any

      Data to write to the backend

    • Optional o: any = {}

      Options object

    Returns any

    • If successful, info about the stored data

storeLocalUserInfo

stringify

  • stringify(data, __namedParameters?): Promise<any>

  • Parameters

    • data: any
    • __namedParameters: {
          ref: any;
      } = {}
      • ref: any

    Returns Promise<any>

syncWith

  • syncWith(backend): void

  • Sync the logged in user, i.e. log in passively when another backend has logged in and log out when another backend has logged out. Generally intended to be used for backends with the same authentication mechanism. Syncing is not two-way, you need to call this on the other backend as well to make it so.

    Parameters

    Returns void

toString

update

  • update(url, o): void

  • Update an existing backend instance with new parameters

    Parameters

    • url: string

      Same as constructor

    • o: any

      Same as constructor

    Returns void

updatePermissions

upload

  • upload(file, options): Promise<void>

  • Parameters

    • file: any
    • options: any

    Returns Promise<void>

Static find

Static from

  • from(url, o?): any

  • Return the appropriate backend(s) for this url

    Parameters

    • url: string

      URL describing the storage location

    • Optional o: {
          existing: Backend | Backend[];
      } = {}

      Options object to be passed to the backend

      • existing: Backend | Backend[]

        Existing backend object(s) to re-use if possible

    Returns any

Static getOAuthBackend

Static load

Static parseURL

Static phrase

Static register

Static test

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc