formatting

Author: jacobprall

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqlitecloud/drivers",
-  "version": "1.0.355",
+  "version": "1.0.357",
   "description": "SQLiteCloud drivers for Typescript/Javascript in edge, web and node clients",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

src/SQLiteCloudClient.ts

@@ -1,117 +1,126 @@
-import { Database } from './drivers/database';
-import { SQLiteCloudError } from './drivers/types';
-import { Fetch, fetchWithAuth } from './drivers/fetch';
-import { DEFAULT_HEADERS, DEFAULT_WEBLITE_VERSION, WEBLITE_PORT } from './drivers/constants';
+import { Database } from './drivers/database'
+import { SQLiteCloudError, UploadOptions } from './drivers/types'
+import { Fetch, fetchWithAuth } from './drivers/fetch'
+import { DEFAULT_HEADERS, DEFAULT_WEBLITE_VERSION, WEBLITE_PORT } from './drivers/constants'
+import { PubSub } from './drivers/pubsub-refactor'
 
 interface SQLiteCloudClientConfig {
-  connectionString: string;
-  fetch?: Fetch;
+  connectionString: string
+  fetch?: Fetch
+}
+
+interface ISQLiteCloudClient {
+  pubSub: PubSub
+  db: Database
+  upload(databaseName: string, file: File | Buffer | Blob | string, opts?: UploadOptions): Promise<Response>
+  download(databaseName: string): Promise<ArrayBuffer | Blob>
+  delete(databaseName: string): Promise<Response>
+  listDatabases(): Promise<any>
 }
 
 const parseConnectionString = (connectionString: string) => {
-  const url = new URL(connectionString);
+  const url = new URL(connectionString)
   return {
     host: url.hostname,
     port: url.port,
     database: url.pathname.slice(1),
-    apiKey: url.searchParams.get('apikey'),
+    apiKey: url.searchParams.get('apikey')
   }
 }
 
-type UploadOptions = {
-  replace?: boolean;
-}
-
-class SQLiteCloudClient {
+export class SQLiteCloudClient implements ISQLiteCloudClient {
   // TODO: Add support for custom fetch
   private fetch: Fetch
   private connectionString: string
   private webliteUrl: string
-  public db: Database
+  private _db: Database
+  private _pubSub: PubSub
 
   constructor(config: SQLiteCloudClientConfig | string) {
-    let connectionString: string;
+    let connectionString: string
     if (typeof config === 'string') {
-      connectionString = config;
+      connectionString = config
     } else {
-      connectionString = config.connectionString;
+      connectionString = config.connectionString
     }
-    // TODO: validate connection string
-    this.connectionString = connectionString;
-    this.db = new Database(this.connectionString);
 
-    const {
-      host,
-      apiKey,
-    } = parseConnectionString(this.connectionString);
+    this.connectionString = connectionString
+    this._db = new Database(this.connectionString)
+    this._pubSub = new PubSub(this.db)
+    this.fetch = fetchWithAuth(this.connectionString)
 
-    if (!apiKey) {
-      throw new SQLiteCloudError('apiKey is required');
-    }
+    const { host } = parseConnectionString(this.connectionString)
+
+    this.webliteUrl = `https://${host}:${WEBLITE_PORT}/${DEFAULT_WEBLITE_VERSION}/weblite`
+  }
+
+  get pubSub() {
+    return this._pubSub
+  }
 
-    this.fetch = fetchWithAuth(this.connectionString);
-    this.webliteUrl = `https://${host}:${WEBLITE_PORT}/${DEFAULT_WEBLITE_VERSION}/weblite`;
+  get db() {
+    return this._db
   }
 
   async upload(databaseName: string, file: File | Buffer | Blob | string, opts: UploadOptions = {}) {
-    const url = `${this.webliteUrl}/${databaseName}`;
-    let body;
+    const url = `${this.webliteUrl}/${databaseName}`
+    let body
     if (file instanceof File) {
-      body = file;
+      body = file
     } else if (file instanceof Buffer) {
-      body = file;
+      body = file
     } else if (file instanceof Blob) {
-      body = file;
+      body = file
     } else {
       // string
-      body = new Blob([file]);
+      body = new Blob([file])
     }
 
     const headers = {
       'Content-Type': 'application/octet-stream',
-      'X-Client-Info': DEFAULT_HEADERS['X-Client-Info'],
+      'X-Client-Info': DEFAULT_HEADERS['X-Client-Info']
     }
 
-    const method = opts.replace ? 'PATCH' : 'POST';
+    const method = opts.replace ? 'PATCH' : 'POST'
 
     const response = await this.fetch(url, { method, body, headers })
 
     if (!response.ok) {
-      throw new SQLiteCloudError(`Failed to upload database: ${response.statusText}`);
+      throw new SQLiteCloudError(`Failed to upload database: ${response.statusText}`)
     }
 
-    return response;
+    return response
   }
 
   async download(databaseName: string) {
-    const url = `${this.webliteUrl}/${databaseName}`;
+    const url = `${this.webliteUrl}/${databaseName}`
     const response = await this.fetch(url, { method: 'GET' })
     if (!response.ok) {
-      throw new SQLiteCloudError(`Failed to download database: ${response.statusText}`);
+      throw new SQLiteCloudError(`Failed to download database: ${response.statusText}`)
     }
-    const isNode = typeof window === 'undefined';
-    return isNode ? await response.arrayBuffer() : await response.blob();
+    const isNode = typeof window === 'undefined'
+    return isNode ? await response.arrayBuffer() : await response.blob()
   }
 
   async delete(databaseName: string) {
-    const url = `${this.webliteUrl}/${databaseName}`;
+    const url = `${this.webliteUrl}/${databaseName}`
     const response = await this.fetch(url, { method: 'DELETE' })
     if (!response.ok) {
-      throw new SQLiteCloudError(`Failed to delete database: ${response.statusText}`);
+      throw new SQLiteCloudError(`Failed to delete database: ${response.statusText}`)
     }
-    return response;
+    return response
   }
 
   async listDatabases() {
-    const url = `${this.webliteUrl}/databases`;
+    const url = `${this.webliteUrl}/databases`
     const response = await this.fetch(url, { method: 'GET' })
     if (!response.ok) {
-      throw new SQLiteCloudError(`Failed to list databases: ${response.statusText}`);
+      throw new SQLiteCloudError(`Failed to list databases: ${response.statusText}`)
     }
-    return await response.json();
+    return await response.json()
   }
 }
 
-export function createClient(config: SQLiteCloudClientConfig | string) {
-  return new SQLiteCloudClient(config);
+export function createClient(config: SQLiteCloudClientConfig | string): SQLiteCloudClient {
+  return new SQLiteCloudClient(config)
 }

src/drivers/constants.ts

@@ -1,4 +1,3 @@
-
 const version = '0.0.1'
 let JS_ENV = ''
 // @ts-ignore
@@ -14,8 +13,8 @@ if (typeof Deno !== 'undefined') {
 
 export const DEFAULT_HEADERS = { 'X-Client-Info': `sqlitecloud-js-${JS_ENV}/${version}` }
 export const DEFAULT_GLOBAL_OPTIONS = {
-  headers: DEFAULT_HEADERS,
+  headers: DEFAULT_HEADERS
 }
 
 export const DEFAULT_WEBLITE_VERSION = 'v2'
-export const WEBLITE_PORT = 8090
+export const WEBLITE_PORT = 8090

src/drivers/database.ts

@@ -14,7 +14,6 @@ import { popCallback } from './utilities'
 import { ErrorCallback, ResultsCallback, RowCallback, RowsCallback } from './types'
 import EventEmitter from 'eventemitter3'
 import { isBrowser } from './utilities'
-import { PubSub } from './pubsub'
 import { Statement } from './statement'
 
 // Uses eventemitter3 instead of node events for browser compatibility
@@ -479,24 +478,4 @@ export class Database extends EventEmitter {
       })
     })
   }
-
-  /**
-   * PubSub class provides a Pub/Sub real-time updates and notifications system to
-   * allow multiple applications to communicate with each other asynchronously.
-   * It allows applications to subscribe to tables and receive notifications whenever
-   * data changes in the database table. It also enables sending messages to anyone
-   * subscribed to a specific channel.
-   * @returns {PubSub} A PubSub object
-   */
-  public async getPubSub(): Promise<PubSub> {
-    return new Promise((resolve, reject) => {
-      this.getConnection((error, connection) => {
-        if (error || !connection) {
-          reject(error)
-        } else {
-          resolve(new PubSub(connection))
-        }
-      })
-    })
-  }
 }

src/drivers/fetch.ts

@@ -1,4 +1,3 @@
-
 import nodeFetch, { Headers as NodeFetchHeaders } from 'node-fetch'
 
 export type Fetch = typeof fetch
@@ -23,14 +22,12 @@ export const resolveHeadersConstructor = () => {
   return Headers
 }
 
-
 export const fetchWithAuth = (authorization: string, customFetch?: Fetch): Fetch => {
-  const fetch = resolveFetch(customFetch);
-  const HeadersConstructor = resolveHeadersConstructor();
-  
+  const fetch = resolveFetch(customFetch)
+  const HeadersConstructor = resolveHeadersConstructor()
 
   return async (input, init) => {
-    const headers = new HeadersConstructor(init?.headers);
+    const headers = new HeadersConstructor(init?.headers)
     if (!headers.has('Authorization')) {
       headers.set('Authorization', `Bearer ${authorization}`)
     }