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

package/dist/index.cjs

@@ -1 +1,786 @@
-"use strict";//# sourceMappingURL=index.cjs.map
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/connection/sqliteConnection.ts
+var _sqlite3 = require('sqlite3'); var _sqlite32 = _interopRequireDefault(_sqlite3);
+var isSQLiteError = (error) => {
+  if (error instanceof Error && "code" in error) {
+    return true;
+  }
+  return false;
+};
+var InMemorySQLiteDatabase = ":memory:";
+var sqliteConnection = (options) => {
+  const db = new _sqlite32.default.Database(_nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase)));
+  return {
+    close: () => db.close(),
+    command: (sql2, params) => new Promise((resolve, reject) => {
+      db.run(sql2, _nullishCoalesce(params, () => ( [])), (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    }),
+    query: (sql2, params) => new Promise((resolve, reject) => {
+      db.all(sql2, _nullishCoalesce(params, () => ( [])), (err, result) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(result);
+      });
+    }),
+    querySingle: (sql2, params) => new Promise((resolve, reject) => {
+      db.get(sql2, _nullishCoalesce(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 {
+  
+  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: _nullishCoalesce(message, () => ( `Expected version ${expected.toString()} does not match current ${_optionalChain([current, 'optionalAccess', _2 => _2.toString, 'call', _3 => _3()])}`))
+    });
+    this.current = current;
+    this.expected = expected;
+    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
+  }
+};
+
+// ../emmett/dist/index.js
+var _uuid = require('uuid');
+var _webstreamspolyfill = require('web-streams-polyfill');
+
+
+
+var _asyncretry = require('async-retry'); var _asyncretry2 = _interopRequireDefault(_asyncretry);
+
+
+
+
+
+
+
+
+
+
+
+
+
+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(_optionalChain([current, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), _optionalChain([expected, 'optionalAccess', _6 => _6.toString, 'call', _7 => _7()]));
+    Object.setPrototypeOf(this, _ExpectedVersionConflictError.prototype);
+  }
+};
+var notifyAboutNoActiveReadersStream = (onNoActiveReaderCallback, options = {}) => new NotifyAboutNoActiveReadersStream(onNoActiveReaderCallback, options);
+var NotifyAboutNoActiveReadersStream = (_class = class extends _webstreamspolyfill.TransformStream {
+  constructor(onNoActiveReaderCallback, options = {}) {
+    super({
+      cancel: (reason) => {
+        console.log("Stream was canceled. Reason:", reason);
+        this.stopChecking();
+      }
+    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.streamId = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.streamId]), () => ( _uuid.v4.call(void 0, )));
+    this.onNoActiveReaderCallback = onNoActiveReaderCallback;
+    this.startChecking(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.intervalCheckInMs]), () => ( 20)));
+  }
+  __init() {this.checkInterval = null}
+  
+  __init2() {this._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();
+    }
+  }
+}, _class);
+var asyncRetry = async (fn, opts) => {
+  if (opts === void 0 || opts.retries === 0) return fn();
+  return _asyncretry2.default.call(void 0, 
+    async (bail) => {
+      try {
+        return await fn();
+      } catch (error2) {
+        if (_optionalChain([opts, 'optionalAccess', _10 => _10.shouldRetryError]) && !opts.shouldRetryError(error2)) {
+          bail(error2);
+        }
+        throw error2;
+      }
+    },
+    _nullishCoalesce(opts, () => ( { retries: 0 }))
+  );
+};
+var ParseError = class extends Error {
+  constructor(text) {
+    super(`Cannot parse! ${text}`);
+  }
+};
+var JSONParser = {
+  stringify: (value, options) => {
+    return JSON.stringify(
+      _optionalChain([options, 'optionalAccess', _11 => _11.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, _optionalChain([options, 'optionalAccess', _12 => _12.reviver]));
+    if (_optionalChain([options, 'optionalAccess', _13 => _13.typeCheck]) && !_optionalChain([options, 'optionalAccess', _14 => _14.typeCheck, 'call', _15 => _15(parsed)]))
+      throw new ParseError(text);
+    return _optionalChain([options, 'optionalAccess', _16 => _16.map]) ? options.map(parsed) : parsed;
+  }
+};
+var filter = (filter2) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    if (filter2(chunk)) {
+      controller.enqueue(chunk);
+    }
+  }
+});
+var map = (map2) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    controller.enqueue(map2(chunk));
+  }
+});
+var reduce = (reducer, initialValue) => new ReduceTransformStream(reducer, initialValue);
+var ReduceTransformStream = class extends _webstreamspolyfill.TransformStream {
+  
+  
+  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 (0, _webstreamspolyfill.TransformStream)({
+  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 = (_class2 = class extends _webstreamspolyfill.TransformStream {
+  __init3() {this.count = 0}
+  
+  constructor(skip2) {
+    super({
+      transform: (chunk, controller) => {
+        this.count++;
+        if (this.count > this.skip) {
+          controller.enqueue(chunk);
+        }
+      }
+    });_class2.prototype.__init3.call(this);;
+    this.skip = skip2;
+  }
+}, _class2);
+var stopAfter = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
+  transform(chunk, controller) {
+    controller.enqueue(chunk);
+    if (stopCondition(chunk)) {
+      controller.terminate();
+    }
+  }
+});
+var stopOn = (stopCondition) => new (0, _webstreamspolyfill.TransformStream)({
+  async transform(chunk, controller) {
+    if (!stopCondition(chunk)) {
+      controller.enqueue(chunk);
+      return;
+    }
+    await Promise.resolve();
+    controller.terminate();
+  }
+});
+var take = (limit) => new TakeTransformStream(limit);
+var TakeTransformStream = (_class3 = class extends _webstreamspolyfill.TransformStream {
+  __init4() {this.count = 0}
+  
+  constructor(limit) {
+    super({
+      transform: (chunk, controller) => {
+        if (this.count < this.limit) {
+          this.count++;
+          controller.enqueue(chunk);
+        } else {
+          controller.terminate();
+        }
+      }
+    });_class3.prototype.__init4.call(this);;
+    this.limit = limit;
+  }
+}, _class3);
+var waitAtMost = (waitTimeInMs) => new (0, _webstreamspolyfill.TransformStream)({
+  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
+
+
+// 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(
+    _optionalChain([options, 'optionalAccess', _17 => _17.expectedStreamVersion])
+  );
+  const messagesToAppend = messages.map(
+    (m, i) => ({
+      ...m,
+      kind: _nullishCoalesce(m.kind, () => ( "Event")),
+      metadata: {
+        streamName,
+        messageId: _uuid.v4.call(void 0, ),
+        streamPosition: BigInt(i + 1),
+        ..."metadata" in m ? _nullishCoalesce(m.metadata, () => ( {})) : {}
+      }
+    })
+  );
+  let result;
+  await db.command(`BEGIN TRANSACTION`);
+  try {
+    result = await appendToStreamRaw(
+      db,
+      streamName,
+      streamType,
+      messagesToAppend,
+      {
+        expectedStreamVersion
+      }
+    );
+    if (_optionalChain([options, 'optionalAccess', _18 => _18.onBeforeCommit]))
+      await options.onBeforeCommit(messagesToAppend, { connection: db });
+  } 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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.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,
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.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,
+          _nullishCoalesce(_optionalChain([options, 'optionalAccess', _21 => _21.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,
+      _nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.partition, 'optionalAccess', _23 => _23.toString, 'call', _24 => _24()]), () => ( defaultTag))
+    );
+    const returningId = await db.querySingle(sqlString, values);
+    if (_optionalChain([returningId, 'optionalAccess', _25 => _25.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 _optionalChain([error, 'optionalAccess', _26 => _26.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 (_optionalChain([result, 'optionalAccess', _27 => _27.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 (_optionalChain([message, 'access', _28 => _28.metadata, 'optionalAccess', _29 => _29.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,
+        _nullishCoalesce(streamPosition.toString(), () => ( 0)),
+        _nullishCoalesce(partition, () => ( defaultTag)),
+        message.kind === "Event" ? "E" : "C",
+        JSONParser.stringify(message.data),
+        JSONParser.stringify(message.metadata),
+        _nullishCoalesce(_optionalChain([expectedStreamVersion, 'optionalAccess', _30 => _30.toString, 'call', _31 => _31()]), () => ( 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/projections/index.ts
+var handleProjections = async (options) => {
+  const { projections: allProjections, events, connection } = options;
+  const eventTypes = events.map((e) => e.type);
+  const projections = allProjections.filter(
+    (p) => p.canHandle.some((type) => eventTypes.includes(type))
+  );
+  for (const projection2 of projections) {
+    await projection2.handle(events, {
+      connection
+    });
+  }
+};
+
+// src/eventStore/SQLiteEventStore.ts
+var SQLiteEventStoreDefaultStreamVersion = 0n;
+var getSQLiteEventStore = (options) => {
+  let schemaMigrated = false;
+  let autoGenerateSchema = false;
+  let database;
+  const fileName = _nullishCoalesce(options.fileName, () => ( InMemorySQLiteDatabase));
+  const isInMemory = fileName === InMemorySQLiteDatabase;
+  const inlineProjections = (_nullishCoalesce(options.projections, () => ( []))).filter(({ type }) => type === "inline").map(({ projection: projection2 }) => projection2);
+  const onBeforeCommitHook = _optionalChain([options, 'access', _32 => _32.hooks, 'optionalAccess', _33 => _33.onBeforeCommit]);
+  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 = _optionalChain([options, 'access', _34 => _34.schema, 'optionalAccess', _35 => _35.autoMigration]) === void 0 || _optionalChain([options, 'access', _36 => _36.schema, 'optionalAccess', _37 => _37.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 = _optionalChain([read, 'optionalAccess', _38 => _38.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,
+          onBeforeCommit: async (messages, context) => {
+            if (inlineProjections.length > 0)
+              await handleProjections({
+                projections: inlineProjections,
+                events: messages,
+                ...context
+              });
+            if (onBeforeCommitHook) await onBeforeCommitHook(messages, context);
+          }
+        })
+      );
+      if (!appendResult.success)
+        throw new ExpectedVersionConflictError(
+          -1n,
+          //TODO: Return actual version in case of error
+          _nullishCoalesce(_optionalChain([options2, 'optionalAccess', _39 => _39.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, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _40 => _40.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 ? _nullishCoalesce(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);
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.SQLiteEventStoreDefaultStreamVersion = SQLiteEventStoreDefaultStreamVersion; exports.appendToStream = appendToStream; exports.createEventStoreSchema = createEventStoreSchema; exports.defaultTag = defaultTag; exports.emmettPrefix = emmettPrefix; exports.getSQLiteEventStore = getSQLiteEventStore; exports.globalNames = globalNames; exports.globalTag = globalTag; exports.isSQLiteError = isSQLiteError; exports.messagesTable = messagesTable; exports.messagesTableSQL = messagesTableSQL; exports.readStream = readStream; exports.schemaSQL = schemaSQL; exports.sql = sql; exports.sqliteConnection = sqliteConnection; exports.streamsTable = streamsTable; exports.streamsTableSQL = streamsTableSQL;
+//# sourceMappingURL=index.cjs.map