@opencode-ai/core 0.0.0-dev-17471

package/dist/database/sqlite.node.js

@@ -0,0 +1,74 @@
+import {
+  exports_sqlite
+} from "../chunks/location-mutation-5rs65q6p.js";
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/database/sqlite.node.ts
+import { DatabaseSync } from "node:sqlite";
+import { Context, Effect, Layer } from "effect";
+import { Reactivity } from "effect/unstable/reactivity";
+import { SqlClient } from "effect/unstable/sql";
+import { classifySqliteError, SqlError } from "effect/unstable/sql/SqlError";
+var TypeId = "~@opencode-ai/core/database/SqliteNode";
+var supportsTuningPragmas = true;
+var supportsForeignKeyToggle = true;
+var make = (options) => Effect.gen(function* () {
+  const native = yield* exports_sqlite.Native;
+  const run = (query, params = []) => Effect.withFiber((fiber) => {
+    const statement = native.prepare(query);
+    statement.setReadBigInts(Context.get(fiber.context, SqlClient.SafeIntegers));
+    try {
+      return Effect.succeed(statement.all(...params));
+    } catch (cause) {
+      return Effect.fail(new SqlError({
+        reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" })
+      }));
+    }
+  });
+  const runValues = (query, params = []) => Effect.withFiber((fiber) => {
+    const statement = native.prepare(query);
+    statement.setReadBigInts(Context.get(fiber.context, SqlClient.SafeIntegers));
+    statement.setReturnArrays(true);
+    try {
+      return Effect.succeed(statement.all(...params));
+    } catch (cause) {
+      return Effect.fail(new SqlError({
+        reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" })
+      }));
+    }
+  });
+  const connection = exports_sqlite.makeConnection(run, runValues, {
+    loadExtension: (path) => Effect.try({
+      try: () => native.loadExtension(path),
+      catch: (cause) => new SqlError({
+        reason: classifySqliteError(cause, { message: "Failed to load extension", operation: "loadExtension" })
+      })
+    })
+  });
+  return yield* exports_sqlite.makeClient(options, connection, TypeId, (acquirer) => ({
+    loadExtension: (path) => Effect.flatMap(acquirer, (_) => _.loadExtension(path))
+  }));
+});
+var nativeLayer = (config) => Layer.effect(exports_sqlite.Native, Effect.gen(function* () {
+  const native = new DatabaseSync(config.filename, {
+    readOnly: config.readonly,
+    timeout: config.timeout,
+    allowExtension: config.allowExtension,
+    enableForeignKeyConstraints: true,
+    open: true
+  });
+  yield* Effect.addFinalizer(() => Effect.sync(() => native.close()));
+  if (config.disableWAL !== true && config.readonly !== true)
+    native.exec("PRAGMA journal_mode = WAL;");
+  return native;
+}));
+var clientLayer = (config) => Layer.effect(SqlClient.SqlClient, make(config));
+var sqliteLayer = (config) => {
+  const native = nativeLayer(config);
+  return Layer.merge(native, clientLayer(config).pipe(Layer.provide(native))).pipe(Layer.provide(Reactivity.layer));
+};
+export {
+  supportsTuningPragmas,
+  supportsForeignKeyToggle,
+  sqliteLayer
+};

package/dist/database/sqlite.workerd.js

@@ -0,0 +1,128 @@
+import {
+  exports_sqlite
+} from "../chunks/location-mutation-5rs65q6p.js";
+import"../chunks/location-mutation-rvfvac9x.js";
+
+// src/database/sqlite.workerd.ts
+import { Context, Effect, Exit, Fiber, Layer, Scope, Semaphore, Stream } from "effect";
+import { identity } from "effect/Function";
+import { Reactivity } from "effect/unstable/reactivity";
+import { SqlClient, Statement } from "effect/unstable/sql";
+import { classifySqliteError, SqlError, UnknownError } from "effect/unstable/sql/SqlError";
+var ATTR_DB_SYSTEM_NAME = "db.system.name";
+var TypeId = "~@opencode-ai/core/database/SqliteWorkerd";
+var supportsTuningPragmas = false;
+var supportsForeignKeyToggle = false;
+var WorkerdTransaction = Context.Service("@opencode-ai/core/database/SqliteWorkerdTransaction");
+var transactionError = (message) => new SqlError({
+  reason: new UnknownError({ cause: new Error(message), message, operation: "transaction" })
+});
+var makeWithTransaction = (storage, connection, semaphore) => (effect) => Effect.withFiber((fiber) => {
+  const services = fiber.context;
+  if (Context.getOption(services, WorkerdTransaction)._tag === "Some")
+    return Effect.fail(transactionError("Nested transactions are not supported by Cloudflare Durable Object SQLite storage"));
+  const effectWithTxn = Effect.provideContext(effect, Context.add(services, WorkerdTransaction, [connection, 0]));
+  return semaphore.withPermits(1)(Effect.callback((resume) => {
+    let interrupted = false;
+    const promise = storage.transaction((txn) => new Promise((resolve) => {
+      if (interrupted)
+        return resolve();
+      resume(Effect.onExit(effectWithTxn, (exit) => {
+        if (Exit.isFailure(exit))
+          txn.rollback();
+        resolve();
+        return Effect.promise(() => promise);
+      }));
+    })).catch((cause) => resume(Effect.fail(new SqlError({
+      reason: classifySqliteError(cause, { message: "Failed transaction", operation: "transaction" })
+    }))));
+    return Effect.suspend(() => {
+      interrupted = true;
+      return Effect.promise(() => promise);
+    });
+  }));
+});
+var make = (options) => Effect.gen(function* () {
+  const native = yield* exports_sqlite.Native;
+  const compiler = Statement.makeCompilerSqlite(options.transformQueryNames);
+  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
+  function* runIterator(query, params = []) {
+    const cursor = native.sql.exec(query, ...params);
+    const columns = cursor.columnNames;
+    for (const row of cursor.raw()) {
+      const record = {};
+      for (let i = 0;i < columns.length; i++) {
+        const value = row[i];
+        record[columns[i]] = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+      }
+      yield record;
+    }
+  }
+  const run = (query, params = []) => Effect.try({
+    try: () => Array.from(runIterator(query, params)),
+    catch: (cause) => new SqlError({
+      reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" })
+    })
+  });
+  const runValues = (query, params = []) => Effect.try({
+    try: () => Array.from(native.sql.exec(query, ...params).raw(), (row) => row.map((value) => value instanceof ArrayBuffer ? new Uint8Array(value) : value)),
+    catch: (cause) => new SqlError({
+      reason: classifySqliteError(cause, { message: "Failed to execute statement", operation: "execute" })
+    })
+  });
+  const connection = identity({
+    execute(query, params, transformRows2) {
+      return transformRows2 ? Effect.map(run(query, params), transformRows2) : run(query, params);
+    },
+    executeRaw(query, params) {
+      return run(query, params);
+    },
+    executeValues(query, params) {
+      return runValues(query, params);
+    },
+    executeValuesUnprepared(query, params) {
+      return runValues(query, params);
+    },
+    executeUnprepared(query, params, transformRows2) {
+      return this.execute(query, params, transformRows2);
+    },
+    executeStream() {
+      return Stream.die("executeStream not implemented");
+    }
+  });
+  const semaphore = yield* Semaphore.make(1);
+  const acquirer = semaphore.withPermits(1)(Effect.succeed(connection));
+  const transactionAcquirer = Effect.uninterruptibleMask((restore) => {
+    const fiber = Fiber.getCurrent();
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope);
+    return Effect.as(Effect.tap(restore(semaphore.take(1)), () => Scope.addFinalizer(scope, semaphore.release(1))), connection);
+  });
+  const client = Object.assign(yield* SqlClient.make({
+    acquirer,
+    compiler,
+    transactionAcquirer,
+    transactionService: WorkerdTransaction,
+    spanAttributes: [
+      ...options.spanAttributes ? Object.entries(options.spanAttributes) : [],
+      [ATTR_DB_SYSTEM_NAME, "sqlite"]
+    ],
+    transformRows
+  }), {
+    [TypeId]: TypeId,
+    config: options,
+    withTransaction: makeWithTransaction(native, connection, semaphore),
+    transactionStatements: false
+  });
+  return client;
+});
+var nativeLayer = (config) => config.storage ? Layer.succeed(exports_sqlite.Native, config.storage) : Layer.effect(exports_sqlite.Native, Effect.die("workerd sqlite cannot open a database from a path; use Database.layerWith(sqliteLayer({ storage }))"));
+var clientLayer = (config) => Layer.effect(SqlClient.SqlClient, make(config));
+var sqliteLayer = (config) => {
+  const native = nativeLayer(config);
+  return Layer.merge(native, clientLayer(config).pipe(Layer.provide(native))).pipe(Layer.provide(Reactivity.layer));
+};
+export {
+  supportsTuningPragmas,
+  supportsForeignKeyToggle,
+  sqliteLayer
+};