All files / core RepoInfo.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
12x
12x
12x
12x
 
 
 
 
 
 
12x
 
 
 
 
 
 
 
 
 
 
 
 
 
49x
49x
49x
147x
 
49x
49x
49x
 
 
12x
47x
 
 
12x
2x
 
 
12x
 
 
 
12x
4x
 
 
 
 
12x
17x
2x
2x
2x
 
 
 
 
 
 
 
 
 
 
12x
47x
47x
 
 
47x
18x
 
29x
29x
 
 
 
 
47x
43x
 
 
47x
 
47x
162x
 
 
47x
 
 
 
12x
108x
108x
 
 
108x
 
 
 
12x
233x
 
12x
 
/**
 * Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
import { assert } from '@firebase/util';
import { forEach } from '@firebase/util';
import { PersistentStorage } from './storage/storage';
import { LONG_POLLING, WEBSOCKET } from '../realtime/Constants';
 
/**
 * A class that holds metadata about a Repo object
 *
 * @constructor
 */
export class RepoInfo {
  host: string;
  domain: string;
  internalHost: string;
 
  /**
   * @param {string} host Hostname portion of the url for the repo
   * @param {boolean} secure Whether or not this repo is accessed over ssl
   * @param {string} namespace The namespace represented by the repo
   * @param {boolean} webSocketOnly Whether to prefer websockets over all other transports (used by Nest).
   * @param {string=} persistenceKey Override the default session persistence storage key
   */
  constructor(
    host: string,
    public secure: boolean,
    public namespace: string,
    public webSocketOnly: boolean,
    public EpersistenceKey: string = ''
  ) {
    this.host = host.toLowerCase();
    this.domain = this.host.substr(this.host.indexOf('.') + 1);
    this.internalHost = PersistentStorage.get('host:' + host) || this.host;
  }
 
  needsQueryParam(): boolean {
    return this.host !== this.internalHost || this.isCustomHost();
  }
 
  isCacheableHost(): boolean {
    return this.internalHost.substr(0, 2) === 's-';
  }
 
  isDemoHost() {
    return this.domain === 'firebaseio-demo.com';
  }
 
  isCustomHost() {
    return (
      this.domain !== 'firebaseio.com' && this.domain !== 'firebaseio-demo.com'
    );
  }
 
  updateHost(newHost: string) {
    if (newHost !== this.internalHost) {
      this.internalHost = newHost;
      Eif (this.isCacheableHost()) {
        PersistentStorage.set('host:' + this.host, this.internalHost);
      }
    }
  }
 
  /**
   * Returns the websocket URL for this repo
   * @param {string} type of connection
   * @param {Object} params list
   * @return {string} The URL for this repo
   */
  connectionURL(type: string, params: { [k: string]: string }): string {
    assert(typeof type === 'string', 'typeof type must == string');
    assert(typeof params === 'object', 'typeof params must == object');
 
    let connURL: string;
    if (type === WEBSOCKET) {
      connURL =
        (this.secure ? 'wss://' : 'ws://') + this.internalHost + '/.ws?';
    } else Eif (type === LONG_POLLING) {
      connURL =
        (this.secure ? 'https://' : 'http://') + this.internalHost + '/.lp?';
    } else {
      throw new Error('Unknown connection type: ' + type);
    }
    if (this.needsQueryParam()) {
      params['ns'] = this.namespace;
    }
 
    const pairs: string[] = [];
 
    forEach(params, (key: string, value: string) => {
      pairs.push(key + '=' + value);
    });
 
    return connURL + pairs.join('&');
  }
 
  /** @return {string} */
  toString(): string {
    let str = this.toURLString();
    Iif (this.persistenceKey) {
      str += '<' + this.persistenceKey + '>';
    }
    return str;
  }
 
  /** @return {string} */
  toURLString(): string {
    return (this.secure ? 'https://' : 'http://') + this.host;
  }
}