diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 4de6b269..868a5cca 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -34,7 +34,7 @@ jobs:
env:
CHINOOK_DATABASE_URL: ${{ secrets.CHINOOK_DATABASE_URL }}
CHINOOK_API_KEY: ${{ secrets.CHINOOK_API_KEY }}
- GATEWAY_URL: ${{ secrets.GATEWAY_URL }}
+ GATEWAY_URL: ${{ vars.GATEWAY_URL }}
run: npm test
- name: Upload Code Coverage
uses: codecov/codecov-action@v4
@@ -260,6 +260,8 @@ jobs:
run: npm i && npx playwright test
env:
VITE_DATABASE_URL: ${{ secrets.CHINOOK_DATABASE_URL }}
+ VITE_DATABASE_API_KEY: ${{ secrets.CHINOOK_API_KEY }}
+ VITE_GATEWAY_URL: ${{ vars.GATEWAY_URL }}
- name: bun with-javascript-vite
if: matrix.os != 'LinuxARM64'
@@ -271,6 +273,8 @@ jobs:
bun playwright test
env:
VITE_DATABASE_URL: ${{ secrets.CHINOOK_DATABASE_URL }}
+ VITE_DATABASE_API_KEY: ${{ secrets.CHINOOK_API_KEY }}
+ VITE_GATEWAY_URL: ${{ vars.GATEWAY_URL }}
- name: deno with-javascript-vite
if: false #matrix.os != 'windows-latest' windows: https://github.com/denoland/deno/issues/23524#issuecomment-2292075726 linux-ubuntu: https://github.com/sqlitecloud/sqlitecloud-js/issues/197
@@ -278,6 +282,8 @@ jobs:
run: deno add npm:@playwright/test && deno run --allow-all npm:playwright test
env:
VITE_DATABASE_URL: ${{ secrets.CHINOOK_DATABASE_URL }}
+ VITE_DATABASE_API_KEY: ${{ secrets.CHINOOK_API_KEY }}
+ VITE_GATEWAY_URL: ${{ vars.GATEWAY_URL }}
PW_DISABLE_TS_ESM: true
- name: remove with-javascript-vite
@@ -287,11 +293,17 @@ jobs:
if: matrix.os != 'LinuxARM64'
working-directory: examples/with-javascript-browser
run: npm i && node test.cjs
+ env:
+ DATABASE_URL: ${{ secrets.CHINOOK_DATABASE_URL }}?apikey=${{ secrets.CHINOOK_API_KEY }}
+ GATEWAY_URL: ${{ vars.GATEWAY_URL }}
- name: bun with-javascript-browser
if: matrix.os != 'windows-latest' && matrix.os != 'LinuxARM64' #cannot launch browsers on windows with bash in commonjs?
working-directory: examples/with-javascript-browser
run: bun i && bun test.cjs
+ env:
+ DATABASE_URL: ${{ secrets.CHINOOK_DATABASE_URL }}?apikey=${{ secrets.CHINOOK_API_KEY }}
+ GATEWAY_URL: ${{ vars.GATEWAY_URL }}
# See issue https://github.com/sqlitecloud/sqlitecloud-js/issues/265
# - name: deno with-javascript-browser
diff --git a/README.md b/README.md
index 0dce12ff..e63ee6bb 100644
--- a/README.md
+++ b/README.md
@@ -70,34 +70,6 @@ We aim for full compatibility with the established [sqlite3 API](https://www.npm
The package is developed entirely in TypeScript and is fully compatible with JavaScript. It doesn't require any native libraries. This makes it a straightforward and effective tool for managing cloud-based databases in a familiar SQLite environment.
-## Publish / Subscribe (Pub/Sub)
-
-```ts
-import { Database } from '@sqlitecloud/drivers'
-import { PubSub, PUBSUB_ENTITY_TYPE } from '@sqlitecloud/drivers/lib/drivers/pubsub'
-
-let database = new Database('sqlitecloud://user:password@xxx.sqlite.cloud:8860/chinook.sqlite')
-// or use sqlitecloud://xxx.sqlite.cloud:8860?apikey=xxxxxxx
-
-const pubSub: PubSub = await database.getPubSub()
-
-await pubSub.listen(PUBSUB_ENTITY_TYPE.TABLE, 'albums', (error, results, data) => {
- if (results) {
- // Changes on albums table will be received here as JSON object
- console.log('Received message:', results)
- }
-})
-
-await database.sql("INSERT INTO albums (Title, ArtistId) values ('Brand new song', 1)")
-
-// Stop listening changes on the table
-await pubSub.unlisten(PUBSUB_ENTITY_TYPE.TABLE, 'albums')
-```
-
-Pub/Sub is a messaging pattern that allows multiple applications to communicate with each other asynchronously. In the context of SQLiteCloud, Pub/Sub can be used to provide real-time updates and notifications to subscribed applications whenever data changes in the database or it can be used to send payloads (messages) to anyone subscribed to a channel.
-
-Pub/Sub Documentation: [https://docs.sqlitecloud.io/docs/pub-sub](https://docs.sqlitecloud.io/docs/pub-sub)
-
## Examples
Check out all the supported platforms with related examples [here](https://github.com/sqlitecloud/sqlitecloud-js/tree/main/examples)!
diff --git a/examples/with-javascript-browser/index.html b/examples/with-javascript-browser/index.html
index 3f622fe0..968343c3 100644
--- a/examples/with-javascript-browser/index.html
+++ b/examples/with-javascript-browser/index.html
@@ -20,6 +20,10 @@ SQLite Cloud Drivers
gatewayUrl
+ sql:
| undefined {
+ if (response?.error && typeof response.error === 'object') {
+ return response.error
+ }
+
+ if (Array.isArray(response?.errors) && response.errors[0] && typeof response.errors[0] === 'object') {
+ return response.errors[0]
+ }
+}
+
/**
* Implementation of TransportConnection that connects to the database indirectly
* via SQLite Cloud Gateway, a socket.io based deamon that responds to sql query
@@ -74,10 +90,28 @@ export class SQLiteCloudWebsocketConnection extends SQLiteCloudConnection {
console.assert(!this.connected, 'Connection already established')
if (!this.socket) {
this.config = config
- const connectionstring = this.config.connectionstring as string
+
const websocketMaxAttachments = parseWebsocketMaxAttachments(this.config.websocketMaxAttachments)
- const gatewayUrl = this.config?.gatewayurl || `${this.config.host === 'localhost' ? 'ws' : 'wss'}://${this.config.host as string}:443`
- this.socket = io(gatewayUrl, { auth: { token: connectionstring }, parser: createSocketIOParser(websocketMaxAttachments) })
+
+ // Gateway tenant routing is derived from the Host header. In production, `gatewayurl` is
+ // a domain suffix (eg `gateway.sqlite.cloud`) appended to the tenant prefix from the core
+ // hostname (eg crvheg7dhk.g4 from crvheg7dhk.g4.sqlite.cloud) to form the gateway host
+ // (→ crvheg7dhk.g4.gateway.sqlite.cloud). For local development, pass a `gatewayurl`
+ // containing `localhost` — the driver routes TCP to it and injects the tenant Host header
+ // separately so the gateway still tenant-routes correctly.
+ const authToken = this.config.apikey || this.config.token
+ const ioOpts: Record = { auth: { token: authToken }, parser: createSocketIOParser(websocketMaxAttachments) }
+ let gatewayUrl: string
+ if (this.config.gatewayurl?.includes('localhost')) {
+ const raw = this.config.gatewayurl
+ gatewayUrl = raw.startsWith('ws://') || raw.startsWith('wss://') ? raw : `ws://${raw}`
+ ioOpts.extraHeaders = { Host: this.config.host }
+ ioOpts.transports = ['websocket']
+ } else {
+ const gatewayHost = buildGatewayHost(this.config.host as string, this.config.gatewayurl)
+ gatewayUrl = `wss://${gatewayHost}:443`
+ }
+ this.socket = io(gatewayUrl, ioOpts)
this.socket.on('connect', () => {
callback?.call(this, null)
@@ -143,6 +177,7 @@ export class SQLiteCloudWebsocketConnection extends SQLiteCloudConnection {
{
sql: commands.query,
bind: encodeBigIntMarkers(commands.parameters),
+ database: this.config.database,
row: 'array',
safe_integer_mode: this.config.safe_integer_mode,
capabilities: {
@@ -150,8 +185,12 @@ export class SQLiteCloudWebsocketConnection extends SQLiteCloudConnection {
}
},
(response: any) => {
- if (response?.error) {
- const error = new SQLiteCloudError(response.error.detail, { ...response.error })
+ const gatewayError = getGatewayResponseError(response)
+ if (gatewayError) {
+ // Gateway error fields (errorCode, externalErrorCode, offsetCode) live under `meta`
+ // for the `errors[]` shape; fall back to top-level for the legacy `error` shape.
+ const errorFields = (gatewayError.meta && typeof gatewayError.meta === 'object') ? gatewayError.meta : gatewayError
+ const error = new SQLiteCloudError(gatewayError.detail || gatewayError.message || 'Gateway error', { ...errorFields })
callback?.call(this, error)
} else {
const { metadata } = response
@@ -192,4 +231,24 @@ export class SQLiteCloudWebsocketConnection extends SQLiteCloudConnection {
}
}
+/** Default gateway domain suffix used when `gatewayurl` is not provided. */
+const DEFAULT_GATEWAY_DOMAIN = 'gateway.sqlite.cloud'
+
+/** Builds the gateway hostname from a core hostname, swapping its last two labels (the
+ * TLD) with the given `gatewayurl` suffix.
+ *
+ * Example: buildGatewayHost('crvheg7dhk.g4.sqlite.cloud')
+ * → 'crvheg7dhk.g4.gateway.sqlite.cloud'
+ *
+ * Returns `host` unchanged when it already ends with the suffix (idempotent) or when
+ * it's too short to extract a tenant prefix (eg 'localhost'). */
+function buildGatewayHost(host: string, gatewayurl?: string): string {
+ if (!host) return host
+ const suffix = gatewayurl || DEFAULT_GATEWAY_DOMAIN
+ if (host === suffix || host.endsWith('.' + suffix)) return host
+ const parts = host.split('.')
+ if (parts.length < 3) return host
+ return parts.slice(0, -2).join('.') + '.' + suffix
+}
+
export default SQLiteCloudWebsocketConnection
diff --git a/src/drivers/database.ts b/src/drivers/database.ts
index 09cde310..77513cf4 100644
--- a/src/drivers/database.ts
+++ b/src/drivers/database.ts
@@ -9,7 +9,6 @@
import EventEmitter from 'eventemitter3'
import { SQLiteCloudConnection } from './connection'
-import { PubSub } from './pubsub'
import { OperationsQueue } from './queue'
import { SQLiteCloudRowset } from './rowset'
import { Statement } from './statement'
@@ -386,7 +385,7 @@ export class Database extends EventEmitter {
public close(callback?: ConnectionCallback): void {
this.operations.enqueue(done => {
this.connection?.close()
-
+
callback?.call(this, null)
this.emitEvent('close')
@@ -477,30 +476,4 @@ export class Database extends EventEmitter {
public isConnected(): boolean {
return this.connection != null && this.connection.connected
}
-
- /**
- * 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 {
- return new Promise((resolve, reject) => {
- this.operations.enqueue(done => {
- let error = null
- try {
- if (!this.connection) {
- error = new SQLiteCloudError('Connection not established', { errorCode: 'ERR_CONNECTION_NOT_ESTABLISHED' })
- reject(error)
- } else {
- resolve(new PubSub(this.connection))
- }
- } finally {
- done(error)
- }
- })
- })
- }
}
diff --git a/src/drivers/pubsub.ts b/src/drivers/pubsub.ts
deleted file mode 100644
index 45ae8599..00000000
--- a/src/drivers/pubsub.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import { SQLiteCloudConnection } from './connection'
-import SQLiteCloudTlsConnection from './connection-tls'
-import { PubSubCallback } from './types'
-
-export enum PUBSUB_ENTITY_TYPE {
- TABLE = 'TABLE',
- CHANNEL = 'CHANNEL'
-}
-
-/**
- * Pub/Sub class to receive changes on database tables or to send messages to channels.
- */
-export class PubSub {
- constructor(connection: SQLiteCloudConnection) {
- this.connection = connection
- this.connectionPubSub = new SQLiteCloudTlsConnection(connection.getConfig())
- }
-
- private connection: SQLiteCloudConnection
- 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
- * @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 {
- const entity = entityType === 'TABLE' ? 'TABLE ' : ''
-
- const authCommand: string = await this.connection.sql(`LISTEN ${entity}${entityName};`)
-
- return new Promise((resolve, reject) => {
- this.connectionPubSub.sendCommands(authCommand, (error, results) => {
- if (error) {
- callback.call(this, error, null, data)
- reject(error)
- } else {
- // skip results from pubSub auth command
- if (results !== 'OK') {
- callback.call(this, null, results, data)
- }
- resolve(results)
- }
- })
- })
- }
-
- /**
- * Stop receive messages from a table or channel.
- * @param entityType One of TABLE or CHANNEL
- * @param entityName Name of the table or the channel
- */
- public async unlisten(entityType: string, entityName: string): Promise {
- const subject = entityType === 'TABLE' ? 'TABLE ' : ''
-
- return this.connection.sql(`UNLISTEN ${subject}?;`, entityName)
- }
-
- /**
- * Create a channel to send messages to.
- * @param name Channel name
- * @param failIfExists Raise an error if the channel already exists
- */
- public async createChannel(name: string, failIfExists: boolean = true): Promise {
- let notExistsCommand = ''
- if (!failIfExists) {
- notExistsCommand = ' IF NOT EXISTS'
- }
-
- return this.connection.sql(`CREATE CHANNEL ?${notExistsCommand};`, name)
- }
-
- /**
- * Deletes a Pub/Sub channel.
- * @param name Channel name
- */
- public async removeChannel(name: string): Promise {
- return this.connection.sql('REMOVE CHANNEL ?;', name)
- }
-
- /**
- * Send a message to the channel.
- */
- public notifyChannel(channelName: string, message: string): Promise {
- return this.connection.sql('NOTIFY ? ?;', channelName, message)
- }
-
- /**
- * Ask the server to close the connection to the database and
- * to keep only open the Pub/Sub connection.
- * Only interaction with Pub/Sub commands will be allowed.
- */
- public setPubSubOnly(): Promise {
- return new Promise((resolve, reject) => {
- this.connection.sendCommands('PUBSUB ONLY;', (error, results) => {
- if (error) {
- reject(error)
- } else {
- this.connection.close()
- resolve(results)
- }
- })
- })
- }
-
- /** True if Pub/Sub connection is open. */
- public connected(): boolean {
- return this.connectionPubSub.connected
- }
-
- /** Close Pub/Sub connection. */
- public close(): void {
- this.connectionPubSub.close()
- }
-}
diff --git a/src/drivers/types.ts b/src/drivers/types.ts
index ac46efc0..99689d90 100644
--- a/src/drivers/types.ts
+++ b/src/drivers/types.ts
@@ -35,7 +35,9 @@ if (SAFE_INTEGER_MODE == 'bigint') {
console.debug('BigInt mode: Using Number for all INTEGER values from SQLite, including meta information from WRITE statements.')
}
if (SAFE_INTEGER_MODE == 'mixed') {
- console.debug('Mixed mode: Using BigInt for INTEGER values from SQLite (including meta information from WRITE statements) bigger then 2^53, Number otherwise.')
+ console.debug(
+ 'Mixed mode: Using BigInt for INTEGER values from SQLite (including meta information from WRITE statements) bigger then 2^53, Number otherwise.'
+ )
}
/**
@@ -95,7 +97,14 @@ export interface SQLiteCloudConfig {
/** True if we should force use of SQLite Cloud Gateway and websocket connections, default: true in browsers, false in node.js */
usewebsocket?: boolean
- /** Url where we can connect to a SQLite Cloud Gateway that has a socket.io deamon waiting to connect, eg. wss://host:443 */
+ /** Domain suffix used to build the gateway hostname the driver connects to.
+ * Default: `gateway.sqlite.cloud`.
+ *
+ * Example: with `host: 'crvheg7dhk.g4.sqlite.cloud'` and the default `gatewayurl`,
+ * the driver opens `wss://crvheg7dhk.g4.gateway.sqlite.cloud:443`. For local
+ * development, pass a value containing `localhost` (eg `'ws://localhost:4000'`)
+ * and the driver will route TCP to that target while forwarding `host` as the
+ * gateway Host header. */
gatewayurl?: string
/** Preferred blob transfer format when using websocket transport. Defaults to base64-blobs-v1 for new clients. */
websocketBlobFormat?: SQLiteCloudWebsocketBlobTransferFormat
@@ -171,7 +180,6 @@ export type ResultsCallback = (error: Error | null, results?: T) => voi
export type RowsCallback> = (error: Error | null, rows?: T[]) => void
export type RowCallback> = (error: Error | null, row?: T) => void
export type RowCountCallback = (error: Error | null, rowCount?: number) => void
-export type PubSubCallback = (error: Error | null, results?: T, extraData?: T) => void
/**
* Certain responses include arrays with various types of metadata.
diff --git a/src/drivers/utilities.ts b/src/drivers/utilities.ts
index 1cc77d25..fd1b6cdd 100644
--- a/src/drivers/utilities.ts
+++ b/src/drivers/utilities.ts
@@ -392,9 +392,7 @@ export function decodeWebsocketRowsetData(
return decodeBigIntMarkers(data, safeIntegerMode)
}
- const blobColumnIndexes = new Set(
- metadata.columns.flatMap((column, index) => (column.type && BLOB_COLUMN_TYPE_RE.test(column.type) ? [index] : []))
- )
+ const blobColumnIndexes = new Set(metadata.columns.flatMap((column, index) => (column.type && BLOB_COLUMN_TYPE_RE.test(column.type) ? [index] : [])))
const decodeCell = (value: any, columnIndex: number) => {
if (blobTransferFormat === 'base64-blobs-v1' && blobColumnIndexes.has(columnIndex) && typeof value === 'string') {
return Buffer.from(value, 'base64')
diff --git a/test/blob-transport.test.ts b/test/blob-transport.test.ts
index 58e68f37..9cdec235 100644
--- a/test/blob-transport.test.ts
+++ b/test/blob-transport.test.ts
@@ -75,8 +75,7 @@ describe('blob rowsets across transports', () => {
try {
database = getChinookDatabase(undefined, {
- usewebsocket: true,
- gatewayurl: GATEWAY_URL
+ usewebsocket: true
})
await assertBlobRowsRoundTrip(database)
} finally {
diff --git a/test/connection-ws-unit.test.ts b/test/connection-ws-unit.test.ts
index 5cf86f99..968810fc 100644
--- a/test/connection-ws-unit.test.ts
+++ b/test/connection-ws-unit.test.ts
@@ -29,10 +29,10 @@ describe('websocket transport helpers', () => {
const connection = Object.create(SQLiteCloudWebsocketConnection.prototype) as any
const connectionstring = 'sqlitecloud://host.sqlite.cloud/database?apikey=secret'
- connection.connectTransport({ connectionstring, host: 'host.sqlite.cloud', websocketMaxAttachments: 321 }, jest.fn())
+ connection.connectTransport({ connectionstring, host: 'host.sqlite.cloud', apikey: 'secret', websocketMaxAttachments: 321 }, jest.fn())
- expect(mockedIo).toHaveBeenCalledWith('wss://host.sqlite.cloud:443', {
- auth: { token: connectionstring },
+ expect(mockedIo).toHaveBeenCalledWith('wss://host.gateway.sqlite.cloud:443', {
+ auth: { token: 'secret' },
parser: expect.objectContaining({
Encoder: expect.any(Function),
Decoder: expect.any(Function)
@@ -84,6 +84,7 @@ describe('websocket transport helpers', () => {
{
sql: 'SELECT ?',
bind: ['123n'],
+ database: undefined,
row: 'array',
safe_integer_mode: 'bigint',
capabilities: {
@@ -162,6 +163,38 @@ describe('websocket transport helpers', () => {
})
})
+ it('should read gateway errors from the errors array response field', done => {
+ const connection = Object.create(SQLiteCloudWebsocketConnection.prototype) as any
+ const emit = jest.fn((_event: string, _payload: any, callback: (response: any) => void) => {
+ callback({
+ errors: [
+ {
+ detail: 'Gateway validation failed.',
+ errorCode: '40001',
+ externalErrorCode: '0',
+ offsetCode: -1
+ }
+ ]
+ })
+ })
+ connection.socket = { connected: true, emit }
+ connection.config = {}
+
+ connection.transportCommands('SELECT 1', (error: any, results?: SQLiteCloudRowset) => {
+ try {
+ expect(results).toBeUndefined()
+ expect(error).toBeDefined()
+ expect(error.message).toBe('Gateway validation failed.')
+ expect(error.errorCode).toBe('40001')
+ expect(error.externalErrorCode).toBe('0')
+ expect(error.offsetCode).toBe(-1)
+ done()
+ } catch (error) {
+ done(error as Error)
+ }
+ })
+ })
+
it('should surface an actionable error when socket.io attachment limits are exceeded', () => {
const handlers: Record void> = {}
const socket = {
diff --git a/test/connection-ws.test.ts b/test/connection-ws.test.ts
index 72f058aa..e4237ba0 100644
--- a/test/connection-ws.test.ts
+++ b/test/connection-ws.test.ts
@@ -83,7 +83,10 @@ describe('connection-ws', () => {
connection = new SQLiteCloudWebsocketConnection(configObj, error => {
try {
expect(error).toBeDefined()
- expect(error?.message).toContain('Error: getaddrinfo ENOTFOUND non.existing.host.name')
+ // The driver rewrites the last two labels of `host` to the configured gateway suffix
+ // (see buildGatewayHost in connection-ws.ts), so the rejected DNS name carries the
+ // surviving `non.existing.` prefix but a tenant-routed suffix.
+ expect(error?.message).toContain('Error: getaddrinfo ENOTFOUND non.existing.')
connection?.close()
} finally {
done()
diff --git a/test/pubsub.test.ts b/test/pubsub.test.ts
deleted file mode 100644
index da1f2060..00000000
--- a/test/pubsub.test.ts
+++ /dev/null
@@ -1,212 +0,0 @@
-import { SQLiteCloudRow } from '../src'
-import { getChinookDatabase, LONG_TIMEOUT } from './shared'
-import { PUBSUB_ENTITY_TYPE } from '../src/drivers/pubsub'
-
-describe('pubSub', () => {
- it(
- 'should listen, notify and receive pubSub messages on channel',
- async () => {
- const connection = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- const channelName = 'test-channel-' + crypto.randomUUID()
- let callbackCalled = false
- const message = 'Message in a bottle ' + Math.floor(Math.random() * 999)
-
- await pubSub.createChannel(channelName)
-
- await pubSub.listen(
- PUBSUB_ENTITY_TYPE.CHANNEL,
- channelName,
- (error, results, data) => {
- expect(error).toBeNull()
-
- expect(results).not.toBeNull()
- expect(results['channel']).toEqual(channelName)
- expect(results['payload']).toEqual(message)
- expect(data).toEqual({ pippo: 'pluto' })
- callbackCalled = true
- },
- { pippo: 'pluto' }
- )
-
- await pubSub.notifyChannel(channelName, message)
-
- while (!callbackCalled) {
- await new Promise(resolve => setTimeout(resolve, 1000))
- }
-
- expect(callbackCalled).toBeTruthy()
- pubSub.removeChannel(channelName)
- } finally {
- connection.close()
- pubSub.close()
- }
- },
- LONG_TIMEOUT
- ),
- it('should unlisten on channel', async () => {
- const connection = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- const channelName = 'test-channel-' + Math.floor(Math.random() * 999)
-
- await pubSub.createChannel(channelName, false)
-
- await pubSub.listen(PUBSUB_ENTITY_TYPE.CHANNEL, channelName, (error, results, data) => {
- expect(true).toBeFalsy()
- })
-
- let connections = await connection.sql`LIST PUBSUB CONNECTIONS;`
- let connectionExists = connections.find((row: SQLiteCloudRow) => row['chname'] === channelName)
- expect(connectionExists).toBeDefined()
-
- await pubSub.unlisten(PUBSUB_ENTITY_TYPE.CHANNEL, channelName)
-
- connections = await connection.sql`LIST PUBSUB CONNECTIONS;`
- connectionExists = connections.find((row: SQLiteCloudRow) => row['chname'] === channelName)
- expect(connectionExists).toBeUndefined()
- } finally {
- connection.close()
- pubSub.close()
- }
- }),
- it('should unlisten on table', async () => {
- const connection = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- let callbackCalled = false
-
- const tableName = 'genres'
- await pubSub.listen(PUBSUB_ENTITY_TYPE.TABLE, tableName, (error, results, data) => {
- expect(true).toBeFalsy()
- callbackCalled = true
- })
-
- let connections = await connection.sql`LIST PUBSUB CONNECTIONS;`
- let connectionExists = connections.find((row: SQLiteCloudRow) => row['chname'] === tableName)
- expect(connectionExists).toBeDefined()
-
- await pubSub.unlisten(PUBSUB_ENTITY_TYPE.TABLE, tableName)
-
- await connection.sql`UPDATE genres SET Name = 'Rock' WHERE GenreId = 1`
-
- // wait a moment to see if the callback is called
- await new Promise(resolve => setTimeout(resolve, 2000))
-
- expect(callbackCalled).toBeFalsy()
- } finally {
- connection.close()
- pubSub.close()
- }
- }),
- it('should fail to create a channel that already exists', async () => {
- const connection = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- const channelName = 'test-channel-' + crypto.randomUUID()
-
- await pubSub.createChannel(channelName)
-
- await expect(pubSub.createChannel(channelName, true)).rejects.toThrow(`Cannot create channel ${channelName} because it already exists.`)
- } finally {
- connection.close()
- pubSub.close()
- }
- }),
- it(
- 'should listen and receive pubSub messages on table',
- async () => {
- const connection = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- let callbackCalled = false
- const newName = 'Rock' + Math.floor(Math.random() * 999)
-
- await pubSub.listen(
- PUBSUB_ENTITY_TYPE.TABLE,
- 'genres',
- (error, results, data) => {
- expect(error).toBeNull()
-
- expect(results).not.toBeNull()
- expect(results['payload'][0]['sqlite_type']).toEqual('UPDATE')
- expect(results['payload'][0]['Name']).toEqual(newName)
- expect(data).toEqual({ pippo: 'pluto' })
- callbackCalled = true
- },
- { pippo: 'pluto' }
- )
-
- await connection.sql`UPDATE genres SET Name = ${newName} WHERE GenreId = 1`
-
- while (!callbackCalled) {
- await new Promise(resolve => setTimeout(resolve, 1000))
- }
-
- expect(callbackCalled).toBeTruthy()
- } finally {
- connection.close()
- pubSub.close()
- }
- },
- LONG_TIMEOUT
- ),
- it('should be connected', async () => {
- const connection = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- expect(pubSub.connected()).toBeTruthy()
-
- pubSub.close()
-
- expect(pubSub.connected()).toBeFalsy()
- } finally {
- connection.close()
- pubSub.close()
- }
- }),
- it(
- 'should keep pubSub only connection',
- async () => {
- const connection = getChinookDatabase()
- const connection2 = getChinookDatabase()
- const pubSub = await connection.getPubSub()
-
- try {
- let callbackCalled = false
- const newName = 'Rock' + Math.floor(Math.random() * 999)
-
- await pubSub.listen(PUBSUB_ENTITY_TYPE.TABLE, 'genres', (error, results, data) => {
- expect(error).toBeNull()
- expect(results).not.toBeNull()
- callbackCalled = true
- })
-
- await pubSub.setPubSubOnly()
-
- expect(connection.sql`SELECT 1`).rejects.toThrow('Connection unavailable. Maybe it got disconnected?')
- expect(pubSub.connected()).toBeTruthy()
-
- await connection2.sql`UPDATE genres SET Name = ${newName} WHERE GenreId = 1`
-
- while (!callbackCalled) {
- await new Promise(resolve => setTimeout(resolve, 1000))
- }
-
- expect(callbackCalled).toBeTruthy()
- } finally {
- connection.close()
- pubSub.close()
- connection2.close()
- }
- },
- LONG_TIMEOUT
- )
-})
diff --git a/test/safe-integers.test.ts b/test/safe-integers.test.ts
new file mode 100644
index 00000000..3c5991ec
--- /dev/null
+++ b/test/safe-integers.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, test } from '@jest/globals'
+import { decodeBigIntMarkers, encodeBigIntMarkers, parseSafeIntegerMode } from '../src/drivers/utilities'
+
+describe('safe integer markers', () => {
+ test('parseSafeIntegerMode validates supported values', () => {
+ expect(parseSafeIntegerMode('bigint')).toBe('bigint')
+ expect(parseSafeIntegerMode('mixed')).toBe('mixed')
+ expect(parseSafeIntegerMode('number')).toBe('number')
+ expect(parseSafeIntegerMode('invalid')).toBe('number')
+ })
+
+ test('decodeBigIntMarkers decodes marker strings only for lossless modes', () => {
+ expect(decodeBigIntMarkers('9223372036854775807n', 'bigint')).toBe(BigInt('9223372036854775807'))
+ expect(decodeBigIntMarkers({ id: '9223372036854775807n' }, 'mixed')).toEqual({ id: BigInt('9223372036854775807') })
+ expect(decodeBigIntMarkers('9223372036854775807n', 'number')).toBe('9223372036854775807n')
+ })
+
+ test('encodeBigIntMarkers encodes bigint values and bigint-mode integer numbers', () => {
+ expect(encodeBigIntMarkers({ id: BigInt('9223372036854775807'), count: 42 })).toEqual({ id: '9223372036854775807n', count: 42 })
+ expect(encodeBigIntMarkers(9223372036854776000)).toBe(9223372036854776000)
+ })
+})
diff --git a/test/shared.ts b/test/shared.ts
index 8e5d7ae9..dc5177d1 100644
--- a/test/shared.ts
+++ b/test/shared.ts
@@ -94,6 +94,10 @@ export function getChinookConfig(url = CHINOOK_DATABASE_URL, extraConfig?: Parti
ca: SELF_SIGNED_CERTIFICATE
}
}
+ if (!chinookConfig.apikey && !chinookConfig.token && CHINOOK_API_KEY) {
+ chinookConfig.apikey = CHINOOK_API_KEY
+ }
+ chinookConfig.gatewayurl = GATEWAY_URL
chinookConfig.timeout = 10 * 1000 // 10 seconds
if (extraConfig) {
chinookConfig = { ...chinookConfig, ...extraConfig }