@event-driven-io/emmett-sqlite 0.32.0 → 0.33.0

package/dist/index.js

@@ -1 +1,758 @@
+// src/connection/sqliteConnection.ts
+import sqlite3 from "sqlite3";
+var isSQLiteError = (error) => {
+  if (error instanceof Error && "code" in error) {
+    return true;
+  }
+  return false;
+};
+var InMemorySQLiteDatabase = ":memory:";
+var sqliteConnection = (options) => {
+  const db = new sqlite3.Database(options.fileName ?? InMemorySQLiteDatabase);
+  return {
+    close: () => db.close(),
+    command: (sql2, params) => new Promise((resolve, reject) => {
+      db.run(sql2, params ?? [], (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    }),
+    query: (sql2, params) => new Promise((resolve, reject) => {
+      db.all(sql2, params ?? [], (err, result) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(result);
+      });
+    }),
+    querySingle: (sql2, params) => new Promise((resolve, reject) => {
+      db.get(sql2, params ?? [], (err, result) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(result);
+      });
+    })
+  };
+};
+
+// ../emmett/dist/chunk-4E7QLAH5.js
+var isNumber = (val) => typeof val === "number" && val === val;
+var isString = (val) => typeof val === "string";
+var EmmettError = class _EmmettError extends Error {
+  errorCode;
+  constructor(options) {
+    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : 500;
+    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during Emmett processing`;
+    super(message);
+    this.errorCode = errorCode;
+    Object.setPrototypeOf(this, _EmmettError.prototype);
+  }
+};
+var ConcurrencyError = class _ConcurrencyError extends EmmettError {
+  constructor(current, expected, message) {
+    super({
+      errorCode: 412,
+      message: message ?? `Expected version ${expected.toString()} does not match current ${current?.toString()}`
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+
+// ../emmett/dist/index.js
+import { v4 as uuid3 } from "uuid";
+import { TransformStream } from "web-streams-polyfill";
+import { v4 as uuid2 } from "uuid";
+import { v4 as uuid } from "uuid";
+import { TransformStream as TransformStream2 } from "web-streams-polyfill";
+import retry from "async-retry";
+import { ReadableStream } from "web-streams-polyfill";
+import "web-streams-polyfill";
+import { TransformStream as TransformStream3 } from "web-streams-polyfill";
+import { TransformStream as TransformStream4 } from "web-streams-polyfill";
+import { TransformStream as TransformStream5 } from "web-streams-polyfill";
+import {
+  TransformStream as TransformStream6
+} from "web-streams-polyfill";
+import { TransformStream as TransformStream7 } from "web-streams-polyfill";
+import { TransformStream as TransformStream8 } from "web-streams-polyfill";
+import { TransformStream as TransformStream9 } from "web-streams-polyfill";
+import { TransformStream as TransformStream10 } from "web-streams-polyfill";
+import { TransformStream as TransformStream11 } from "web-streams-polyfill";
+var STREAM_EXISTS = "STREAM_EXISTS";
+var STREAM_DOES_NOT_EXIST = "STREAM_DOES_NOT_EXIST";
+var NO_CONCURRENCY_CHECK = "NO_CONCURRENCY_CHECK";
+var matchesExpectedVersion = (current, expected, defaultVersion) => {
+  if (expected === NO_CONCURRENCY_CHECK) return true;
+  if (expected == STREAM_DOES_NOT_EXIST) return current === defaultVersion;
+  if (expected == STREAM_EXISTS) return current !== defaultVersion;
+  return current === expected;
+};
+var assertExpectedVersionMatchesCurrent = (current, expected, defaultVersion) => {
+  expected ??= NO_CONCURRENCY_CHECK;
+  if (!matchesExpectedVersion(current, expected, defaultVersion))
+    throw new ExpectedVersionConflictError(current, expected);
+};
+var ExpectedVersionConflictError = class _ExpectedVersionConflictError extends ConcurrencyError {
+  constructor(current, expected) {
+    super(current?.toString(), expected?.toString());
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
+  }
+};
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = class extends TransformStream2 {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = options?.streamId ?? uuid();
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(options?.intervalCheckInMs ?? 20);
+  }
+  checkInterval = null;
+  streamId;
+  _isStopped = false;
+  get hasActiveSubscribers() {
+    return !this._isStopped;
+  }
+  startChecking(interval) {
+    this.checkInterval = setInterval(() => {
+      this.checkNoActiveReader();
+    }, interval);
+  }
+  stopChecking() {
+    if (!this.checkInterval) return;
+    clearInterval(this.checkInterval);
+    this.checkInterval = null;
+    this._isStopped = true;
+    this.onNoActiveReaderCallback(this);
+  }
+  checkNoActiveReader() {
+    if (!this.readable.locked && !this._isStopped) {
+      this.stopChecking();
+    }
+  }
+};
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return retry(
+    async (bail) => {
+      try {
+        return await fn();
+      } catch (error2) {
+        if (opts?.shouldRetryError && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    opts ?? { retries: 0 }
+  );
+};
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      options?.map ? options.map(value) : value,
+      //TODO: Consider adding support to DateTime and adding specific format to mark that's a bigint
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      (_, v) => typeof v === "bigint" ? v.toString() : v
+    );
+  },
+  parse: (text, options) => {
+    const parsed = JSON.parse(text, options?.reviver);
+    if (options?.typeCheck && !options?.typeCheck(parsed))
+      throw new ParseError(text);
+    return options?.map ? options.map(parsed) : parsed;
+  }
+};
+var filter = (filter2) => new TransformStream3({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+var map = (map2) => new TransformStream4({
+  transform(chunk, controller) {
+    controller.enqueue(map2(chunk));
+  }
+});
+var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
+var ReduceTransformStream = class extends TransformStream5 {
+  accumulator;
+  reducer;
+  constructor(reducer, initialValue) {
+    super({
+      transform: (chunk) => {
+        this.accumulator = this.reducer(this.accumulator, chunk);
+      },
+      flush: (controller) => {
+        controller.enqueue(this.accumulator);
+        controller.terminate();
+      }
+    });
+    this.accumulator = initialValue;
+    this.reducer = reducer;
+  }
+};
+var retryStream = (createSourceStream, handleChunk2, retryOptions = { forever: true, minTimeout: 25 }) => new TransformStream6({
+  start(controller) {
+    asyncRetry(
+      () => onRestream(createSourceStream, handleChunk2, controller),
+      retryOptions
+    ).catch((error2) => {
+      controller.error(error2);
+    });
+  }
+});
+var onRestream = async (createSourceStream, handleChunk2, controller) => {
+  const sourceStream = createSourceStream();
+  const reader = sourceStream.getReader();
+  try {
+    let done;
+    do {
+      const result = await reader.read();
+      done = result.done;
+      await handleChunk2(result, controller);
+      if (done) {
+        controller.terminate();
+      }
+    } while (!done);
+  } finally {
+    reader.releaseLock();
+  }
+};
+var skip = (limit) => new SkipTransformStream(limit);
+var SkipTransformStream = class extends TransformStream7 {
+  count = 0;
+  skip;
+  constructor(skip2) {
+    super({
+      transform: (chunk, controller) => {
+        this.count++;
+        if (this.count > this.skip) {
+          controller.enqueue(chunk);
+        }
+      }
+    });
+    this.skip = skip2;
+  }
+};
+var stopAfter = (stopCondition) => new TransformStream8({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+var stopOn = (stopCondition) => new TransformStream9({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = class extends TransformStream10 {
+  count = 0;
+  limit;
+  constructor(limit) {
+    super({
+      transform: (chunk, controller) => {
+        if (this.count < this.limit) {
+          this.count++;
+          controller.enqueue(chunk);
+        } else {
+          controller.terminate();
+        }
+      }
+    });
+    this.limit = limit;
+  }
+};
+var waitAtMost = (waitTimeInMs) => new TransformStream11({
+  start(controller) {
+    const timeoutId = setTimeout(() => {
+      controller.terminate();
+    }, waitTimeInMs);
+    const originalTerminate = controller.terminate.bind(controller);
+    controller.terminate = () => {
+      clearTimeout(timeoutId);
+      originalTerminate();
+    };
+  },
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+  }
+});
+var streamTransformations = {
+  filter,
+  take,
+  TakeTransformStream,
+  skip,
+  SkipTransformStream,
+  map,
+  notifyAboutNoActiveReadersStream,
+  NotifyAboutNoActiveReadersStream,
+  reduce,
+  ReduceTransformStream,
+  retry: retryStream,
+  stopAfter,
+  stopOn,
+  waitAtMost
+};
+var { retry: retry2 } = streamTransformations;
+
+// src/eventStore/schema/appendToStream.ts
+import { v4 as uuid4 } from "uuid";
+
+// src/eventStore/schema/typing.ts
+var emmettPrefix = "emt";
+var globalTag = "global";
+var defaultTag = "emt:default";
+var globalNames = {
+  module: `${emmettPrefix}:module:${globalTag}`
+};
+var columns = {
+  partition: {
+    name: "partition"
+  },
+  isArchived: { name: "is_archived" }
+};
+var streamsTable = {
+  name: `${emmettPrefix}_streams`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+var messagesTable = {
+  name: `${emmettPrefix}_messages`,
+  columns: {
+    partition: columns.partition,
+    isArchived: columns.isArchived
+  }
+};
+
+// src/eventStore/schema/appendToStream.ts
+var appendToStream = async (db, streamName, streamType, messages, options) => {
+  if (messages.length === 0) return { success: false };
+  const expectedStreamVersion = toExpectedVersion(
+    options?.expectedStreamVersion
+  );
+  const messagesToAppend = messages.map(
+    (m, i) => ({
+      ...m,
+      kind: m.kind ?? "Event",
+      metadata: {
+        streamName,
+        messageId: uuid4(),
+        streamPosition: BigInt(i + 1),
+        ..."metadata" in m ? m.metadata ?? {} : {}
+      }
+    })
+  );
+  let result;
+  await db.command(`BEGIN TRANSACTION`);
+  try {
+    result = await appendToStreamRaw(
+      db,
+      streamName,
+      streamType,
+      messagesToAppend,
+      {
+        expectedStreamVersion
+      }
+    );
+    if (options?.preCommitHook) options.preCommitHook(messagesToAppend);
+  } catch (err) {
+    await db.command(`ROLLBACK`);
+    throw err;
+  }
+  if (result.success == null || !result.success) {
+    await db.command(`ROLLBACK`);
+    return result;
+  }
+  await db.command(`COMMIT`);
+  return result;
+};
+var toExpectedVersion = (expected) => {
+  if (expected === void 0) return null;
+  if (expected === NO_CONCURRENCY_CHECK) return null;
+  if (expected == STREAM_DOES_NOT_EXIST) return null;
+  if (expected == STREAM_EXISTS) return null;
+  return expected;
+};
+var appendToStreamRaw = async (db, streamId, streamType, messages, options) => {
+  let streamPosition;
+  let globalPosition;
+  try {
+    let expectedStreamVersion = options?.expectedStreamVersion ?? null;
+    if (expectedStreamVersion == null) {
+      expectedStreamVersion = await getLastStreamPosition(
+        db,
+        streamId,
+        expectedStreamVersion
+      );
+    }
+    let position;
+    if (expectedStreamVersion === 0n) {
+      position = await db.querySingle(
+        `INSERT INTO ${streamsTable.name}
+            (stream_id, stream_position, partition, stream_type, stream_metadata, is_archived)
+            VALUES  (
+                ?,
+                ?,
+                ?,
+                ?,
+                '[]',
+                false
+            )
+            RETURNING stream_position;
+          `,
+        [
+          streamId,
+          messages.length,
+          options?.partition ?? streamsTable.columns.partition,
+          streamType
+        ]
+      );
+    } else {
+      position = await db.querySingle(
+        `UPDATE ${streamsTable.name}
+            SET stream_position = stream_position + ?
+            WHERE stream_id = ?
+            AND partition = ?
+            AND is_archived = false
+            RETURNING stream_position;
+          `,
+        [
+          messages.length,
+          streamId,
+          options?.partition ?? streamsTable.columns.partition
+        ]
+      );
+    }
+    if (position == null) {
+      throw new Error("Could not find stream position");
+    }
+    streamPosition = BigInt(position.stream_position);
+    if (expectedStreamVersion != null) {
+      const expectedStreamPositionAfterSave = BigInt(expectedStreamVersion) + BigInt(messages.length);
+      if (streamPosition !== expectedStreamPositionAfterSave) {
+        return {
+          success: false
+        };
+      }
+    }
+    const { sqlString, values } = buildMessageInsertQuery(
+      messages,
+      expectedStreamVersion,
+      streamId,
+      options?.partition?.toString() ?? defaultTag
+    );
+    const returningId = await db.querySingle(sqlString, values);
+    if (returningId?.global_position == null) {
+      throw new Error("Could not find global position");
+    }
+    globalPosition = BigInt(returningId.global_position);
+  } catch (err) {
+    if (isSQLiteError(err) && isOptimisticConcurrencyError(err)) {
+      return {
+        success: false
+      };
+    }
+    throw err;
+  }
+  return {
+    success: true,
+    nextStreamPosition: streamPosition,
+    lastGlobalPosition: globalPosition
+  };
+};
+var isOptimisticConcurrencyError = (error) => {
+  return error?.errno !== void 0 && error.errno === 19;
+};
+async function getLastStreamPosition(db, streamId, expectedStreamVersion) {
+  const result = await db.querySingle(
+    `SELECT CAST(stream_position AS VARCHAR) AS stream_position FROM ${streamsTable.name} WHERE stream_id = ?`,
+    [streamId]
+  );
+  if (result?.stream_position == null) {
+    expectedStreamVersion = 0n;
+  } else {
+    expectedStreamVersion = BigInt(result.stream_position);
+  }
+  return expectedStreamVersion;
+}
+var buildMessageInsertQuery = (messages, expectedStreamVersion, streamId, partition) => {
+  const query = messages.reduce(
+    (queryBuilder, message) => {
+      if (message.metadata?.streamPosition == null || typeof message.metadata.streamPosition !== "bigint") {
+        throw new Error("Stream position is required");
+      }
+      const streamPosition = BigInt(message.metadata.streamPosition) + BigInt(expectedStreamVersion);
+      queryBuilder.parameterMarkers.push(`(?,?,?,?,?,?,?,?,?,?)`);
+      queryBuilder.values.push(
+        streamId,
+        streamPosition.toString() ?? 0,
+        partition ?? defaultTag,
+        message.kind === "Event" ? "E" : "C",
+        JSONParser.stringify(message.data),
+        JSONParser.stringify(message.metadata),
+        expectedStreamVersion?.toString() ?? 0,
+        message.type,
+        message.metadata.messageId,
+        false
+      );
+      return queryBuilder;
+    },
+    {
+      parameterMarkers: [],
+      values: []
+    }
+  );
+  const sqlString = `
+      INSERT INTO ${messagesTable.name} (
+          stream_id, 
+          stream_position, 
+          partition, 
+          message_kind,
+          message_data, 
+          message_metadata, 
+          message_schema_version, 
+          message_type, 
+          message_id, 
+          is_archived
+      ) 
+      VALUES ${query.parameterMarkers.join(", ")} 
+      RETURNING 
+        CAST(global_position as VARCHAR) AS global_position
+    `;
+  return { sqlString, values: query.values };
+};
+
+// src/eventStore/SQLiteEventStore.ts
+var SQLiteEventStoreDefaultStreamVersion = 0n;
+var getSQLiteEventStore = (options) => {
+  let schemaMigrated = false;
+  let autoGenerateSchema = false;
+  let database;
+  const fileName = options.fileName ?? InMemorySQLiteDatabase;
+  const isInMemory = fileName === InMemorySQLiteDatabase;
+  const createConnection = () => {
+    if (database != null) {
+      return database;
+    }
+    return sqliteConnection({
+      fileName
+    });
+  };
+  const closeConnection = () => {
+    if (isInMemory) {
+      return;
+    }
+    if (database != null) {
+      database.close();
+      database = null;
+    }
+  };
+  const withConnection = async (handler) => {
+    if (database == null) {
+      database = createConnection();
+    }
+    try {
+      await ensureSchemaExists(database);
+      return await handler(database);
+    } finally {
+      closeConnection();
+    }
+  };
+  if (options) {
+    autoGenerateSchema = options.schema?.autoMigration === void 0 || options.schema?.autoMigration !== "None";
+  }
+  const ensureSchemaExists = async (connection) => {
+    if (!autoGenerateSchema) return Promise.resolve();
+    if (!schemaMigrated) {
+      await createEventStoreSchema(connection);
+      schemaMigrated = true;
+    }
+    return Promise.resolve();
+  };
+  return {
+    async aggregateStream(streamName, options2) {
+      const { evolve, initialState, read } = options2;
+      const expectedStreamVersion = read?.expectedStreamVersion;
+      let state = initialState();
+      if (typeof streamName !== "string") {
+        throw new Error("Stream name is not string");
+      }
+      if (database == null) {
+        database = createConnection();
+      }
+      const result = await withConnection(
+        (db) => readStream(db, streamName, options2.read)
+      );
+      const currentStreamVersion = result.currentStreamVersion;
+      assertExpectedVersionMatchesCurrent(
+        currentStreamVersion,
+        expectedStreamVersion,
+        SQLiteEventStoreDefaultStreamVersion
+      );
+      for (const event of result.events) {
+        if (!event) continue;
+        state = evolve(state, event);
+      }
+      return {
+        currentStreamVersion,
+        state,
+        streamExists: result.streamExists
+      };
+    },
+    readStream: async (streamName, options2) => withConnection((db) => readStream(db, streamName, options2)),
+    appendToStream: async (streamName, events, options2) => {
+      if (database == null) {
+        database = createConnection();
+      }
+      const [firstPart, ...rest] = streamName.split("-");
+      const streamType = firstPart && rest.length > 0 ? firstPart : "emt:unknown";
+      const appendResult = await withConnection(
+        (db) => appendToStream(db, streamName, streamType, events, options2)
+      );
+      if (!appendResult.success)
+        throw new ExpectedVersionConflictError(
+          -1n,
+          //TODO: Return actual version in case of error
+          options2?.expectedStreamVersion ?? NO_CONCURRENCY_CHECK
+        );
+      return {
+        nextExpectedStreamVersion: appendResult.nextStreamPosition,
+        lastEventGlobalPosition: appendResult.lastGlobalPosition,
+        createdNewStream: appendResult.nextStreamPosition >= BigInt(events.length)
+      };
+    }
+  };
+};
+
+// src/eventStore/schema/readStream.ts
+var readStream = async (db, streamId, options) => {
+  const fromCondition = options && "from" in options ? `AND stream_position >= ${options.from}` : "";
+  const to = Number(
+    options && "to" in options ? options.to : options && "maxCount" in options && options.maxCount ? options.from + options.maxCount : NaN
+  );
+  const toCondition = !isNaN(to) ? `AND stream_position <= ${to}` : "";
+  const results = await db.query(
+    `SELECT stream_id, stream_position, global_position, message_data, message_metadata, message_schema_version, message_type, message_id
+           FROM ${messagesTable.name}
+           WHERE stream_id = ? AND partition = ? AND is_archived = FALSE ${fromCondition} ${toCondition}`,
+    [streamId, options?.partition ?? defaultTag]
+  );
+  const messages = results.map((row) => {
+    const rawEvent = {
+      type: row.message_type,
+      data: JSONParser.parse(row.message_data),
+      metadata: JSONParser.parse(row.message_metadata)
+    };
+    const metadata = {
+      ..."metadata" in rawEvent ? rawEvent.metadata ?? {} : {},
+      messageId: row.message_id,
+      streamName: streamId,
+      streamPosition: BigInt(row.stream_position),
+      globalPosition: BigInt(row.global_position)
+    };
+    return {
+      ...rawEvent,
+      kind: "Event",
+      metadata
+    };
+  });
+  return messages.length > 0 ? {
+    currentStreamVersion: messages[messages.length - 1].metadata.streamPosition,
+    events: messages,
+    streamExists: true
+  } : {
+    currentStreamVersion: SQLiteEventStoreDefaultStreamVersion,
+    events: [],
+    streamExists: false
+  };
+};
+
+// src/eventStore/schema/tables.ts
+var sql = (sql2) => sql2;
+var streamsTableSQL = sql(
+  `CREATE TABLE IF NOT EXISTS ${streamsTable.name}(
+      stream_id         TEXT                      NOT NULL,
+      stream_position   BIGINT                    NOT NULL DEFAULT 0,
+      partition         TEXT                      NOT NULL DEFAULT '${globalTag}',
+      stream_type       TEXT                      NOT NULL,
+      stream_metadata   JSONB                     NOT NULL,
+      is_archived       BOOLEAN                   NOT NULL DEFAULT FALSE,
+      PRIMARY KEY (stream_id, stream_position, partition, is_archived),
+      UNIQUE (stream_id, partition, is_archived)
+  );`
+);
+var messagesTableSQL = sql(
+  `CREATE TABLE IF NOT EXISTS ${messagesTable.name}(
+      stream_id              TEXT                      NOT NULL,
+      stream_position        BIGINT                    NOT NULL,
+      partition              TEXT                      NOT NULL DEFAULT '${globalTag}',
+      message_kind           CHAR(1)                   NOT NULL DEFAULT 'E',
+      message_data           JSONB                     NOT NULL,
+      message_metadata       JSONB                     NOT NULL,
+      message_schema_version TEXT                      NOT NULL,
+      message_type           TEXT                      NOT NULL,
+      message_id             TEXT                      NOT NULL,
+      is_archived            BOOLEAN                   NOT NULL DEFAULT FALSE,
+      global_position        INTEGER                   PRIMARY KEY,
+      created                DATETIME                  DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE (stream_id, stream_position, partition, is_archived)
+  ); 
+`
+);
+var schemaSQL = [streamsTableSQL, messagesTableSQL];
+var createEventStoreSchema = async (db) => {
+  for (const sql2 of schemaSQL) {
+    await db.command(sql2);
+  }
+};
+export {
+  InMemorySQLiteDatabase,
+  SQLiteEventStoreDefaultStreamVersion,
+  appendToStream,
+  createEventStoreSchema,
+  defaultTag,
+  emmettPrefix,
+  getSQLiteEventStore,
+  globalNames,
+  globalTag,
+  isSQLiteError,
+  messagesTable,
+  messagesTableSQL,
+  readStream,
+  schemaSQL,
+  sql,
+  sqliteConnection,
+  streamsTable,
+  streamsTableSQL
+};
 //# sourceMappingURL=index.js.map