poad 2.1.1

package/src/lib/auth.ts

@@ -0,0 +1,306 @@
+import { parseJwt, getHashParams, isBrowser, uuid, urlBase64Decode } from './util'
+import { Capacitor } from '@capacitor/core'
+import { Browser } from '@capacitor/browser'
+import type { MailPhoneProps, PasswordCredentials, ProviderProps, EmailResetProps } from './types'
+
+export default class OmneediaAuth {
+  protected ref: any
+  protected tokenListener: any = null
+  private options: any
+  constructor(ref: any, options?: any) {
+    this.options = options
+    this.ref = ref
+    this.tokenListener = setInterval(async () => {
+      if (isBrowser()) {
+        /** look storage */
+        let session = await this.session().getUser()
+        if (!session) return
+        let refresh = localStorage.getItem('omneedia.auth.refresh_token')
+        if (!refresh) {
+          localStorage.removeItem('omneedia.auth.token')
+          localStorage.removeItem('omneedia.auth.refresh_token')
+          return (location.href = `#new_token=${refresh}`)
+        }
+        let date = new Date(session.exp * 1000)
+        if (date < new Date()) {
+          let token = await this.getNewToken(refresh)
+          if (token === false) {
+            localStorage.removeItem('omneedia.auth.token')
+            localStorage.removeItem('omneedia.auth.refresh_token')
+            return (location.href = `#new_token=${refresh}`)
+          }
+          localStorage.setItem('omneedia.auth.token', token)
+          return (location.href = `#new_token=${refresh}`)
+        }
+      } else {
+        let session = await this.session().getUser()
+        if (!session) return
+      }
+    }, 1000)
+  }
+  public async getNewToken(refresh_token: string | null): Promise<any> {
+    let { data } = await this.ref.request.post(
+      this.ref.PREFIX.AUTH + '/token?grant_type=refresh_token',
+      {
+        refresh_token: refresh_token,
+      }
+    )
+    var response: string | null | boolean
+    if (data.error) response = false
+    else {
+      response = data.access_token
+    }
+    return response
+  }
+  private _setUserData(data: any) {
+    this.options.cookies.setAll([
+      {
+        name: 'omneedia.auth.token',
+        value: data.access_token,
+        lifetime: 60 * 3600 * 8,
+        domain: '',
+        path: '/',
+        sameSite: 'None',
+      },
+    ])
+  }
+  public async signInWithPassword(props: PasswordCredentials) {
+    let { data } = await this.ref.request.post(
+      this.ref.PREFIX.AUTH + '/token?grant_type=password',
+      {
+        props,
+      }
+    )
+    if (isBrowser()) {
+      if (data.error) url = [`#error=${data.error}`]
+      else {
+        var url = []
+        for (var el in data) url.push(`${el}=${data[el]}`)
+      }
+      location.href = '#' + url.join('&')
+    } else {
+      if (data.error) return { data: { user: null, session: null }, error: { message: data.error } }
+      this._setUserData(data)
+      return this.getUser(data.access_token)
+    }
+  }
+  public async signUp(props: PasswordCredentials) {
+    let { data } = await this.ref.request.post(this.ref.PREFIX.AUTH + '/signup', {
+      props,
+    })
+    console.log(data)
+    if (isBrowser()) {
+      if (data.error) url = [`#error=${data.error}`]
+      else {
+        var url = []
+        for (var el in data) url.push(`${el}=${data[el]}`)
+      }
+      if (data.waiting) url = [`#waiting`]
+      location.href = '#' + url.join('&')
+    } else {
+      if (data.error) return { data: { user: null, session: null }, error: { message: data.error } }
+      this._setUserData(data)
+      return this.getUser(data.access_token)
+    }
+  }
+  public async signInWithProvider(props: ProviderProps) {
+    // generateId :: Integer -> String
+    const generateId = (len?: number) => {
+      const dec2hex = (dec: number) => {
+        return dec.toString(16).padStart(2, '0')
+      }
+      var arr = new Uint8Array((len || 40) / 2)
+      window.crypto.getRandomValues(arr)
+      return Array.from(arr, dec2hex).join('')
+    }
+    if (props.config?.callback) {
+      return (location.href = `${this.ref.URI}${this.ref.PREFIX.AUTH}/authorize?provider=${props.provider}&callback=${props.config.callback}`)
+    }
+    const platform = await Capacitor.getPlatform()
+    const getSession = async (uid: string) => {
+      let { data } = await this.ref.request.post(this.ref.PREFIX.AUTH + '/session', {
+        sid: uid,
+      })
+      if (isBrowser()) {
+        if (data?.uri) {
+          location.hash = data.uri
+          Browser.close()
+        } else
+          setTimeout(() => {
+            getSession(uid)
+          }, 1000)
+      }
+      if (platform === 'ios' || platform === 'android') {
+        const uid = generateId()
+        getSession(uid)
+        Browser.open({
+          url: `${this.ref.URI}${this.ref.PREFIX.AUTH}/authorize?provider=${props.provider}&sid=${uid}`,
+        })
+      } else {
+        var win = window.open(
+          `${this.ref.URI}${this.ref.PREFIX.AUTH}/authorize?provider=${props.provider}`,
+          '_blank'
+        )
+        window.addEventListener(
+          'message',
+          (event) => {
+            return (location.hash = event.data)
+          },
+          false
+        )
+      }
+    }
+    return true
+  }
+  public async updateUser(props: any) {
+    const urlParams = new URLSearchParams(window.location.search)
+    const token = urlParams.get('token')
+    if (token) props.token = token
+    let { data } = await this.ref.request.put(this.ref.PREFIX.AUTH + '/user', props)
+    return data
+  }
+  public onAuthStateChange(fn: Function) {
+    if (isBrowser()) {
+      var HashChange = () => {
+        if (location.href.indexOf('access_token') > -1) {
+          var params = getHashParams()
+          window.location.hash = ''
+          localStorage.setItem('omneedia.auth.token', params.access_token)
+          localStorage.setItem('omneedia.auth.refresh_token', params.refresh_token)
+          return fn('SIGNED_IN', params)
+        }
+        if (location.href.indexOf('#waiting') > -1) {
+          window.location.hash = ''
+          return fn('WAITING_FOR_CONFIRMATION', {})
+        }
+        if (location.href.indexOf('#logout') > -1) {
+          localStorage.removeItem('omneedia.auth.token')
+          localStorage.removeItem('omneedia.auth.refresh_token')
+          window.location.hash = ''
+          return fn('SIGNED_OUT', {})
+        }
+        if (location.href.indexOf('#error') > -1) {
+          var token = decodeURIComponent(location.href).split('#error=')[1]
+          fn('ERROR', token)
+          window.location.hash = ''
+          return false
+        }
+        if (location.href.indexOf('#new_token') > -1) {
+          var token = decodeURIComponent(location.href).split('#new_token=')[1]
+          fn('REFRESH_TOKEN', localStorage.getItem('omneedia.auth.token'))
+          window.location.hash = ''
+          return false
+        }
+
+        if (localStorage.getItem('omneedia.auth.token')) {
+          fn('AUTHENTICATED', localStorage.getItem('omneedia.auth.token'))
+        }
+      }
+      window.addEventListener('hashchange', HashChange)
+      window.addEventListener('load', HashChange)
+      HashChange()
+    } else {
+      // cookie based auth
+    }
+  }
+
+  public async resetPasswordForEmail(props: EmailResetProps) {
+    let { data } = await this.ref.request.post(this.ref.PREFIX.AUTH + '/recover', props)
+
+    if (data.error) url = [`error=${data.error}`]
+    else {
+      var url = []
+      for (var el in data) url.push(`${el}=${data[el]}`)
+    }
+    if (data.waiting) url = [`waiting`]
+    location.href = '#' + url.join('&')
+  }
+  public async signInWithEmail(props: MailPhoneProps) {
+    let { data } = await this.ref.request.post(this.ref.PREFIX.AUTH + '/magiclink', props)
+    if (data.error) url = [`error=${data.error}`]
+    else {
+      var url = []
+      for (var el in data) url.push(`${el}=${data[el]}`)
+    }
+    if (data.waiting) url = [`waiting`]
+    location.href = '#' + url.join('&')
+  }
+  public getSession(): boolean | any {
+    var session = false
+    if (isBrowser()) {
+      if (localStorage.getItem('omneedia.auth.token')) {
+        let token: string | null = localStorage.getItem('omneedia.auth.token')!
+        session = parseJwt(token)
+      }
+    } else {
+      // use cookie
+    }
+    return {
+      getUser: (): any => {
+        return session
+      },
+    }
+  }
+  public session = this.getSession
+  public async getUser(token?: string | null) {
+    if (token) {
+      if (isBrowser()) {
+        try {
+          token = urlBase64Decode(token)
+          return token
+        } catch (e) {
+          return null
+        }
+      } else {
+        const decoded = urlBase64Decode(token)
+        if (!decoded) return { data: { user: null, session: null }, error: null }
+        if (decoded.role == 'anon') {
+          return { data: { user: null, session: null }, error: { message: 'anonymous' } }
+        }
+        return { data: { user: decoded, session: token }, error: null }
+      }
+    }
+    let { data } = await this.ref.request.get(this.ref.PREFIX.AUTH + '/user')
+    if (!data) return { data: { user: null, session: null }, error: { message: 'anonymous' } }
+    if (data.role == 'anon') {
+      return { data: { user: null, session: null }, error: { message: 'anonymous' } }
+    }
+    if (data === false) {
+      if (isBrowser()) {
+        localStorage.removeItem('omneedia.auth.token')
+        localStorage.removeItem('omneedia.auth.refresh_token')
+      } else {
+        // use cookie
+        this.options.cookies.deleteAll()
+      }
+    }
+    if (isBrowser()) return data
+    else return { data: { user: data }, error: null }
+  }
+  public isAuthenticated() {
+    if (isBrowser()) {
+      if (window.localStorage.getItem('omneedia.auth.token')) return true
+      else return false
+    }
+  }
+  public async signOut() {
+    if (isBrowser()) {
+      await this.ref.request.get(this.ref.PREFIX.AUTH + '/signout')
+      location.hash = '#logout'
+      return
+    } else {
+      const { data } = await this.ref.request.get(this.ref.PREFIX.AUTH + '/signout')
+      //await this.options.auth.storage.removeItem('omneedia.auth.token')
+      this.options.cookies.setAll([
+        {
+          name: 'omneedia.auth.token',
+          value: data.token,
+          lifetime: new Date(0),
+          domain: '',
+          path: '/',
+          sameSite: 'lax',
+        },
+      ])
+    }
+  }
+}

package/src/lib/constants.ts

@@ -0,0 +1,7 @@
+export const COOKIE_OPTIONS = {
+  name: 'oa:token',
+  lifetime: 60 * 3600 * 8,
+  domain: '',
+  path: '/',
+  sameSite: 'lax',
+}

package/src/lib/db.ts

@@ -0,0 +1,216 @@
+import OARequest from './request'
+
+export default class OmneediaQueryDB {
+  private TABLE: string
+  private SELECT: Array<string> = []
+  private INSERT: Object = {}
+  private UPDATE: Object = {}
+  private DELETE: boolean = false
+  private WHERE: Array<string> = []
+  private ref: any = {}
+  private request: any
+  private FilterOperator = [
+    'eq',
+    'neq',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'like',
+    'ilike',
+    'is',
+    'in',
+    'cs',
+    'cd',
+    'sl',
+    'sr',
+    'nxl',
+    'nxr',
+    'adj',
+    'ov',
+    'fts',
+    'plfts',
+    'phfts',
+    'wfts',
+  ]
+  constructor(table: string, ref: any) {
+    this.TABLE = table
+    this.ref = ref
+    this.request = new OARequest(this)
+  }
+  rangeLt(key: string, value: any) {
+    this.WHERE.push(`${key}=sl.${value}`)
+    return this
+  }
+  rangeGt(key: string, value: any) {
+    this.WHERE.push(`${key}=sr.${value}`)
+    return this
+  }
+  rangeLte(key: string, value: any) {
+    this.WHERE.push(`${key}=nxr.${value}`)
+    return this
+  }
+  rangeGte(key: string, value: any) {
+    this.WHERE.push(`${key}=nxl.${value}`)
+    return this
+  }
+  rangeAdjacent(key: string, value: any) {
+    this.WHERE.push(`${key}=adj.${value}`)
+    return this
+  }
+  overlaps(key: string, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `[${value.join(',')}]`
+    this.WHERE.push(`${key}=ov.${value}`)
+    return this
+  }
+  not(key: string, value: any, o: any) {
+    if (this.FilterOperator.indexOf(value) == -1) return this
+    this.WHERE.push(`${key}=not.${value}.${o}`)
+    return this
+  }
+  is(key: string, value: any) {
+    this.WHERE.push(`${key}=is.${value}`)
+    return this
+  }
+  contains(key: string, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `{${value.join(',')}}`
+    this.WHERE.push(`${key}=cs.${value}`)
+    return this
+  }
+  containedBy(key: any, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `{${value.join(',')}}`
+    this.WHERE.push(`${key}=cd.${value}`)
+    return this
+  }
+  or(key: any) {
+    if (!Array.isArray(key)) key = [key]
+    if (key.length == 1) key = key[0].split(',')
+    this.WHERE.push(`or=(${key.join(',')})`)
+    return this
+  }
+  and(key: any) {
+    if (!Array.isArray(key)) key = [key]
+    if (key.length == 1) key = key[0].split(',')
+    this.WHERE.push(`and=(${key.join(',')})`)
+    return this
+  }
+  textSearch(key: string, value: any, o: any) {
+    let typePart = ''
+    if (o) {
+      if (o.type === 'plain') {
+        typePart = 'pl'
+      } else if (o.type === 'phrase') {
+        typePart = 'ph'
+      } else if (o.type === 'websearch') {
+        typePart = 'w'
+      }
+    }
+    let method = `${typePart}fts`
+    this.WHERE.push(`${key}=${method}.${value}`)
+    return this
+  }
+  in(key: string, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `(${value.join(',')})`
+    this.WHERE.push(`${key}=in.${value}`)
+    return this
+  }
+  nxr(key: string, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `(${value.join(',')})`
+    this.WHERE.push(`${key}=nxr.${value}`)
+    return this
+  }
+  sl(key: string, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `(${value.join(',')})`
+    this.WHERE.push(`${key}=sl.${value}`)
+    return this
+  }
+  adj(key: string, value: any) {
+    if (!Array.isArray(value)) value = [value]
+    value = `(${value.join(',')})`
+    this.WHERE.push(`${key}=adj.${value}`)
+    return this
+  }
+  imatch(key: any) {
+    for (var el in key) {
+      this.WHERE.push(`${el}=eq.${key[el]}`)
+    }
+    return this
+  }
+  match(key: any) {
+    for (var el in key) {
+      this.WHERE.push(`${el}=eq.${key[el]}`)
+    }
+    return this
+  }
+  gt(key: string, value: string) {
+    this.WHERE.push(`${key}=gt.${value}`)
+    return this
+  }
+  gte(key: string, value: string) {
+    this.WHERE.push(`${key}=gte.${value}`)
+    return this
+  }
+  lt(key: string, value: string) {
+    this.WHERE.push(`${key}=lt.${value}`)
+    return this
+  }
+  lte(key: string, value: string) {
+    this.WHERE.push(`${key}=lte.${value}`)
+    return this
+  }
+  neq(key: string, value: string) {
+    this.WHERE.push(`${key}=neq.${value}`)
+    return this
+  }
+  like(key: string, value: string) {
+    this.WHERE.push(`${key}=like.${value}`)
+    return this
+  }
+  ilike(key: string, value: string) {
+    this.WHERE.push(`${key}=ilike.${value}`)
+    return this
+  }
+  eq(key: string, value: string) {
+    this.WHERE.push(`${key}=eq.${value}`)
+    return this
+  }
+  select(...s: any) {
+    if (!s) s = ['']
+    if (s.length == 1) s = s[0].split(',')
+    this.SELECT = s
+    return this
+  }
+  insert(o: any) {
+    this.INSERT = o
+    return this
+  }
+  update(o: any) {
+    this.UPDATE = o
+    return this
+  }
+  delete() {
+    this.DELETE = true
+    return this
+  }
+  async then(resolve: any, reject: any) {
+    var uri = `/${this.TABLE}?`
+    if (Object.keys(this.INSERT).length > 0) {
+      var url = this.ref.PREFIX.REST + uri
+      return resolve(this.request.post(url, this.INSERT))
+    }
+    if (this.SELECT.length > 0) uri += `select=${this.SELECT.join(',')}&`
+    if (this.WHERE.length > 0) uri += this.WHERE.join('&')
+    var url = this.ref.PREFIX.REST + uri
+    var method = 'get'
+    if (this.DELETE === true) method = 'delete'
+    if (Object.keys(this.UPDATE).length > 0) {
+      resolve(this.request.patch(url, this.UPDATE))
+    } else resolve(this.request[method](url))
+  }
+}

package/src/lib/error-codes.ts

@@ -0,0 +1,71 @@
+/**
+ * Known error codes. Note that the server may also return other error codes
+ * not included in this list (if the client library is older than the version
+ * on the server).
+ */
+export type ErrorCode =
+  | 'unexpected_failure'
+  | 'validation_failed'
+  | 'bad_json'
+  | 'email_exists'
+  | 'phone_exists'
+  | 'bad_jwt'
+  | 'not_admin'
+  | 'no_authorization'
+  | 'user_not_found'
+  | 'session_not_found'
+  | 'flow_state_not_found'
+  | 'flow_state_expired'
+  | 'signup_disabled'
+  | 'user_banned'
+  | 'provider_email_needs_verification'
+  | 'invite_not_found'
+  | 'bad_oauth_state'
+  | 'bad_oauth_callback'
+  | 'oauth_provider_not_supported'
+  | 'unexpected_audience'
+  | 'single_identity_not_deletable'
+  | 'email_conflict_identity_not_deletable'
+  | 'identity_already_exists'
+  | 'email_provider_disabled'
+  | 'phone_provider_disabled'
+  | 'too_many_enrolled_mfa_factors'
+  | 'mfa_factor_name_conflict'
+  | 'mfa_factor_not_found'
+  | 'mfa_ip_address_mismatch'
+  | 'mfa_challenge_expired'
+  | 'mfa_verification_failed'
+  | 'mfa_verification_rejected'
+  | 'insufficient_aal'
+  | 'captcha_failed'
+  | 'saml_provider_disabled'
+  | 'manual_linking_disabled'
+  | 'sms_send_failed'
+  | 'email_not_confirmed'
+  | 'phone_not_confirmed'
+  | 'reauth_nonce_missing'
+  | 'saml_relay_state_not_found'
+  | 'saml_relay_state_expired'
+  | 'saml_idp_not_found'
+  | 'saml_assertion_no_user_id'
+  | 'saml_assertion_no_email'
+  | 'user_already_exists'
+  | 'sso_provider_not_found'
+  | 'saml_metadata_fetch_failed'
+  | 'saml_idp_already_exists'
+  | 'sso_domain_already_exists'
+  | 'saml_entity_id_mismatch'
+  | 'conflict'
+  | 'provider_disabled'
+  | 'user_sso_managed'
+  | 'reauthentication_needed'
+  | 'same_password'
+  | 'reauthentication_not_valid'
+  | 'otp_expired'
+  | 'otp_disabled'
+  | 'identity_not_found'
+  | 'weak_password'
+  | 'over_request_rate_limit'
+  | 'over_email_send_rate_limit'
+  | 'over_sms_send_rate_limit'
+  | 'bad_code_verifier'