add upload, download, fetch, create client

Author: jacobprall

bun.lockb

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

package.json

@@ -0,0 +1,117 @@
+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';
+
+interface SQLiteCloudClientConfig {
+  connectionString: string;
+  fetch?: Fetch;
+}
+
+const parseConnectionString = (connectionString: string) => {
+  const url = new URL(connectionString);
+  return {
+    host: url.hostname,
+    port: url.port,
+    database: url.pathname.slice(1),
+    apiKey: url.searchParams.get('apikey'),
+  }
+}
+
+type UploadOptions = {
+  replace?: boolean;
+}
+
+class SQLiteCloudClient {
+  // TODO: Add support for custom fetch
+  private fetch: Fetch
+  private connectionString: string
+  private webliteUrl: string
+  public db: Database
+
+  constructor(config: SQLiteCloudClientConfig | string) {
+    let connectionString: string;
+    if (typeof config === 'string') {
+      connectionString = config;
+    } else {
+      connectionString = config.connectionString;
+    }
+    // TODO: validate connection string
+    this.connectionString = connectionString;
+    this.db = new Database(this.connectionString);
+
+    const {
+      host,
+      apiKey,
+    } = parseConnectionString(this.connectionString);
+
+    if (!apiKey) {
+      throw new SQLiteCloudError('apiKey is required');
+    }
+
+    this.fetch = fetchWithAuth(this.connectionString);
+    this.webliteUrl = `https://${host}:${WEBLITE_PORT}/${DEFAULT_WEBLITE_VERSION}/weblite`;
+  }
+
+  async upload(databaseName: string, file: File | Buffer | Blob | string, opts: UploadOptions = {}) {
+    const url = `${this.webliteUrl}/${databaseName}`;
+    let body;
+    if (file instanceof File) {
+      body = file;
+    } else if (file instanceof Buffer) {
+      body = file;
+    } else if (file instanceof Blob) {
+      body = file;
+    } else {
+      // string
+      body = new Blob([file]);
+    }
+
+    const headers = {
+      'Content-Type': 'application/octet-stream',
+      'X-Client-Info': DEFAULT_HEADERS['X-Client-Info'],
+    }
+
+    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}`);
+    }
+
+    return response;
+  }
+
+  async download(databaseName: string) {
+    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}`);
+    }
+    const isNode = typeof window === 'undefined';
+    return isNode ? await response.arrayBuffer() : await response.blob();
+  }
+
+  async delete(databaseName: string) {
+    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}`);
+    }
+    return response;
+  }
+
+  async listDatabases() {
+    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}`);
+    }
+    return await response.json();
+  }
+}
+
+export function createClient(config: SQLiteCloudClientConfig | string) {
+  return new SQLiteCloudClient(config);
+}

src/SQLiteCloudClient.ts

@@ -0,0 +1,21 @@
+
+const version = '0.0.1'
+let JS_ENV = ''
+// @ts-ignore
+if (typeof Deno !== 'undefined') {
+  JS_ENV = 'deno'
+} else if (typeof document !== 'undefined') {
+  JS_ENV = 'web'
+} else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+  JS_ENV = 'react-native'
+} else {
+  JS_ENV = 'node'
+}
+
+export const DEFAULT_HEADERS = { 'X-Client-Info': `sqlitecloud-js-${JS_ENV}/${version}` }
+export const DEFAULT_GLOBAL_OPTIONS = {
+  headers: DEFAULT_HEADERS,
+}
+
+export const DEFAULT_WEBLITE_VERSION = 'v2'
+export const WEBLITE_PORT = 8090

src/drivers/constants.ts

@@ -0,0 +1,40 @@
+
+import nodeFetch, { Headers as NodeFetchHeaders } from 'node-fetch'
+
+export type Fetch = typeof fetch
+
+export const resolveFetch = (customFetch?: Fetch): Fetch => {
+  let _fetch: Fetch
+  if (customFetch) {
+    _fetch = customFetch
+  } else if (typeof fetch !== 'undefined') {
+    _fetch = nodeFetch as unknown as Fetch
+  } else {
+    _fetch = fetch
+  }
+  return (...args: Parameters<Fetch>) => _fetch(...args)
+}
+
+export const resolveHeadersConstructor = () => {
+  if (typeof Headers === 'undefined') {
+    return NodeFetchHeaders
+  }
+
+  return Headers
+}
+
+
+export const fetchWithAuth = (authorization: string, customFetch?: Fetch): Fetch => {
+  const fetch = resolveFetch(customFetch);
+  const HeadersConstructor = resolveHeadersConstructor();
+  
+
+  return async (input, init) => {
+    const headers = new HeadersConstructor(init?.headers);
+    if (!headers.has('Authorization')) {
+      headers.set('Authorization', `Bearer ${authorization}`)
+    }
+    // @ts-ignore
+    return fetch(input, { ...init, headers })
+  }
+}

src/drivers/fetch.ts

@@ -2,11 +2,12 @@ import { SQLiteCloudConnection } from './connection'
 import SQLiteCloudTlsConnection from './connection-tls'
 import { PubSubCallback } from './types'
 
-export enum PUBSUB_ENTITY_TYPE {
-  TABLE = 'TABLE',
-  CHANNEL = 'CHANNEL'
+interface PubSubOptions {
+  tableName: string
+  dbName?: string
 }
 
+
 /**
  * Pub/Sub class to receive changes on database tables or to send messages to channels.
  */
@@ -20,26 +21,31 @@ export class PubSub {
   private connectionPubSub: SQLiteCloudConnection
 
   /**
-   * Listen for a table or channel and start to receive messages to the provided callback.
-   * @param entityType One of TABLE or CHANNEL'
-   * @param entityName Name of the table or the channel
+   * Listen to a channel and start to receive messages to the provided callback.
+   * @param options Options for the listen operation
    * @param callback Callback to be called when a message is received
-   * @param data Extra data to be passed to the callback
    */
-  public async listen(entityType: PUBSUB_ENTITY_TYPE, entityName: string, callback: PubSubCallback, data?: any): Promise<any> {
-    const entity = entityType === 'TABLE' ? 'TABLE ' : ''
 
-    const authCommand: string = await this.connection.sql(`LISTEN ${entity}${entityName};`)
+  public async listen<T>(options: PubSubOptions, callback: PubSubCallback): Promise<T> {
+    if (options.dbName) {
+      try {
+        await this.connection.sql(`USE DATABASE ${options.dbName};`)
+      } catch (error) {
+        console.error(error)
+      }
+    }
+
+    const authCommand: string = await this.connection.sql(`LISTEN TABLE ${options.tableName};`)
 
     return new Promise((resolve, reject) => {
       this.connectionPubSub.sendCommands(authCommand, (error, results) => {
         if (error) {
-          callback.call(this, error, null, data)
+          callback.call(this, error, null)
           reject(error)
         } else {
           // skip results from pubSub auth command
           if (results !== 'OK') {
-            callback.call(this, null, results, data)
+            callback.call(this, null, results)
           }
           resolve(results)
         }

src/drivers/pubsub.ts

@@ -135,7 +135,7 @@ export type ResultsCallback<T = any> = (error: Error | null, results?: T) => voi
 export type RowsCallback<T = Record<string, any>> = (error: Error | null, rows?: T[]) => void
 export type RowCallback<T = Record<string, any>> = (error: Error | null, row?: T) => void
 export type RowCountCallback = (error: Error | null, rowCount?: number) => void
-export type PubSubCallback<T = any> = (error: Error | null, results?: T, extraData?: T) => void
+export type PubSubCallback<T = any> = (error: Error | null, results?: T) => void
 
 /**
  * Certain responses include arrays with various types of metadata.

src/drivers/types.ts

@@ -20,3 +20,4 @@ export {
 export { SQLiteCloudRowset, SQLiteCloudRow } from './drivers/rowset'
 export { parseconnectionstring, validateConfiguration, getInitializationCommands, sanitizeSQLiteIdentifier } from './drivers/utilities'
 export * as protocol from './drivers/protocol'
+export { createClient } from './SQLiteCloudClient'