@effect/sql-mysql2 0.49.1 → 4.0.0-beta.0

package/src/MysqlClient.ts

@@ -1,22 +1,20 @@
 /**
  * @since 1.0.0
  */
-import * as Reactivity from "@effect/experimental/Reactivity"
-import * as Client from "@effect/sql/SqlClient"
-import type { Connection } from "@effect/sql/SqlConnection"
-import { SqlError } from "@effect/sql/SqlError"
-import { asyncPauseResume } from "@effect/sql/SqlStream"
-import * as Statement from "@effect/sql/Statement"
-import * as Chunk from "effect/Chunk"
 import * as Config from "effect/Config"
-import type { ConfigError } from "effect/ConfigError"
-import * as Context from "effect/Context"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Redacted from "effect/Redacted"
 import type { Scope } from "effect/Scope"
+import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
+import * as Reactivity from "effect/unstable/reactivity/Reactivity"
+import * as Client from "effect/unstable/sql/SqlClient"
+import type { Connection } from "effect/unstable/sql/SqlConnection"
+import { SqlError } from "effect/unstable/sql/SqlError"
+import { asyncPauseResume } from "effect/unstable/sql/SqlStream"
+import * as Statement from "effect/unstable/sql/Statement"
 import * as Mysql from "mysql2"
 
 const ATTR_DB_SYSTEM_NAME = "db.system.name"
@@ -28,13 +26,13 @@ const ATTR_SERVER_PORT = "server.port"
  * @category type ids
  * @since 1.0.0
  */
-export const TypeId: unique symbol = Symbol.for("@effect/sql-mysql2/MysqlClient")
+export const TypeId: TypeId = "~@effect/sql-mysql2/MysqlClient"
 
 /**
  * @category type ids
  * @since 1.0.0
  */
-export type TypeId = typeof TypeId
+export type TypeId = "~@effect/sql-mysql2/MysqlClient"
 
 /**
  * @category models
@@ -49,7 +47,7 @@ export interface MysqlClient extends Client.SqlClient {
  * @category tags
  * @since 1.0.0
  */
-export const MysqlClient = Context.GenericTag<MysqlClient>("@effect/sql-mysql2/MysqlClient")
+export const MysqlClient = ServiceMap.Service<MysqlClient>("@effect/sql-mysql2/MysqlClient")
 
 /**
  * @category models
@@ -94,7 +92,10 @@ export const make = (
       undefined
 
     class ConnectionImpl implements Connection {
-      constructor(private readonly conn: Mysql.PoolConnection | Mysql.Pool) {}
+      readonly conn: Mysql.PoolConnection | Mysql.Pool
+      constructor(conn: Mysql.PoolConnection | Mysql.Pool) {
+        this.conn = conn
+      }
 
       private runRaw(
         sql: string,
@@ -102,7 +103,7 @@ export const make = (
         rowsAsArray = false,
         method: "execute" | "query" = "execute"
       ) {
-        return Effect.async<unknown, SqlError>((resume) => {
+        return Effect.callback<unknown, SqlError>((resume) => {
           ;(this.conn as any)[method]({
             sql,
             values,
@@ -159,10 +160,7 @@ export const make = (
       ) {
         const stream = queryStream(this.conn as any, sql, params)
         return transformRows
-          ? Stream.mapChunks(stream, (_) =>
-            Chunk.unsafeFromArray(
-              transformRows(Chunk.toReadonlyArray(_) as Array<object>)
-            ))
+          ? Stream.mapArray(stream, (_) => transformRows(_) as any)
           : stream
       }
     }
@@ -174,11 +172,11 @@ export const make = (
         supportBigNumbers: true,
         connectionLimit: options.maxConnections!,
         idleTimeout: options.connectionTTL
-          ? Duration.toMillis(options.connectionTTL)
+          ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.connectionTTL))
           : undefined as any
       })
       : Mysql.createPool({
-        ...(options.poolConfig ?? {}),
+        ...options.poolConfig,
         host: options.host,
         port: options.port,
         database: options.database,
@@ -189,14 +187,13 @@ export const make = (
         multipleStatements: true,
         supportBigNumbers: true,
         connectionLimit: options.maxConnections,
-        maxIdle: options.poolConfig?.maxIdle ?? 0,
         idleTimeout: options.connectionTTL
-          ? Duration.toMillis(options.connectionTTL)
+          ? Duration.toMillis(Duration.fromDurationInputUnsafe(options.connectionTTL))
           : undefined
       } as Mysql.PoolOptions)
 
     yield* Effect.acquireRelease(
-      Effect.async<void, SqlError>((resume) => {
+      Effect.callback<void, SqlError>((resume) => {
         ;(pool as any).query("SELECT 1", (cause: Error) => {
           if (cause) {
             resume(Effect.fail(
@@ -211,27 +208,29 @@ export const make = (
         })
       }),
       () =>
-        Effect.async<void>((resume) => {
+        Effect.callback<void>((resume) => {
           pool.end(() => resume(Effect.void))
         })
     ).pipe(
-      Effect.timeoutFail({
+      Effect.timeoutOrElse({
         duration: Duration.seconds(5),
         onTimeout: () =>
-          new SqlError({
-            message: "MysqlClient: Connection timeout",
-            cause: new Error("connection timeout")
-          })
+          Effect.fail(
+            new SqlError({
+              message: "MysqlClient: Connection timeout",
+              cause: new Error("connection timeout")
+            })
+          )
       })
     )
 
     const poolConnection = new ConnectionImpl(pool)
 
     const acquireConn = Effect.acquireRelease(
-      Effect.async<Mysql.PoolConnection, SqlError>((resume) => {
+      Effect.callback<Mysql.PoolConnection, SqlError>((resume) => {
         pool.getConnection((cause, conn) => {
           if (cause) {
-            resume(new SqlError({ cause, message: "Failed to acquire connection" }))
+            resume(Effect.fail(new SqlError({ cause, message: "Failed to acquire connection" })))
           } else {
             resume(Effect.succeed(conn))
           }
@@ -273,14 +272,14 @@ export const make = (
  * @since 1.0.0
  */
 export const layerConfig = (
-  config: Config.Config.Wrap<MysqlClientConfig>
-): Layer.Layer<MysqlClient | Client.SqlClient, ConfigError | SqlError> =>
-  Layer.scopedContext(
-    Config.unwrap(config).pipe(
+  config: Config.Wrap<MysqlClientConfig>
+): Layer.Layer<MysqlClient | Client.SqlClient, Config.ConfigError | SqlError> =>
+  Layer.effectServices(
+    Config.unwrap(config).asEffect().pipe(
       Effect.flatMap(make),
       Effect.map((client) =>
-        Context.make(MysqlClient, client).pipe(
-          Context.add(Client.SqlClient, client)
+        ServiceMap.make(MysqlClient, client).pipe(
+          ServiceMap.add(Client.SqlClient, client)
         )
       )
     )
@@ -292,11 +291,11 @@ export const layerConfig = (
  */
 export const layer = (
   config: MysqlClientConfig
-): Layer.Layer<MysqlClient | Client.SqlClient, ConfigError | SqlError> =>
-  Layer.scopedContext(
+): Layer.Layer<MysqlClient | Client.SqlClient, Config.ConfigError | SqlError> =>
+  Layer.effectServices(
     Effect.map(make(config), (client) =>
-      Context.make(MysqlClient, client).pipe(
-        Context.add(Client.SqlClient, client)
+      ServiceMap.make(MysqlClient, client).pipe(
+        ServiceMap.add(Client.SqlClient, client)
       ))
   ).pipe(Layer.provide(Reactivity.layer))
 
@@ -330,8 +329,10 @@ function queryStream(
   sql: string,
   params?: ReadonlyArray<any>
 ) {
-  return asyncPauseResume<any, SqlError>((emit) => {
+  return asyncPauseResume<any, SqlError>(Effect.fnUntraced(function*(emit) {
     const query = (conn as any).query(sql, params).stream()
+    yield* Effect.addFinalizer(() => Effect.sync(() => query.destroy()))
+
     let buffer: Array<any> = []
     let taskPending = false
     query.on("error", (cause: unknown) => emit.fail(new SqlError({ cause, message: "Failed to stream statement" })))
@@ -347,11 +348,21 @@ function queryStream(
         })
       }
     })
-    query.on("end", () => emit.end())
+    query.on("end", () => {
+      if (buffer.length > 0) {
+        emit.array(buffer)
+        buffer = []
+      }
+      emit.end()
+    })
+
     return {
-      onInterrupt: Effect.sync(() => query.destroy()),
-      onPause: Effect.sync(() => query.pause()),
-      onResume: Effect.sync(() => query.resume())
+      onPause() {
+        query.pause()
+      },
+      onResume() {
+        query.resume()
+      }
     }
-  })
+  }))
 }

package/src/MysqlMigrator.ts

@@ -1,100 +1,80 @@
 /**
  * @since 1.0.0
  */
-import * as Command from "@effect/platform/Command"
-import type { CommandExecutor } from "@effect/platform/CommandExecutor"
-import { FileSystem } from "@effect/platform/FileSystem"
-import { Path } from "@effect/platform/Path"
-import * as Migrator from "@effect/sql/Migrator"
-import type * as Client from "@effect/sql/SqlClient"
-import type { SqlError } from "@effect/sql/SqlError"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
+import type * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
-import * as Redacted from "effect/Redacted"
-import { MysqlClient } from "./MysqlClient.js"
+import * as Migrator from "effect/unstable/sql/Migrator"
+import type * as Client from "effect/unstable/sql/SqlClient"
+import type { SqlError } from "effect/unstable/sql/SqlError"
 
 /**
  * @since 1.0.0
  */
-export * from "@effect/sql/Migrator"
-
-/**
- * @since 1.0.0
- */
-export * from "@effect/sql/Migrator/FileSystem"
+export * from "effect/unstable/sql/Migrator"
 
 /**
  * @category constructor
  * @since 1.0.0
  */
 export const run: <R2 = never>(
-  options: Migrator.MigratorOptions<R2>
+  { loader, schemaDirectory, table }: Migrator.MigratorOptions<R2>
 ) => Effect.Effect<
   ReadonlyArray<readonly [id: number, name: string]>,
   Migrator.MigrationError | SqlError,
-  FileSystem | Path | MysqlClient | Client.SqlClient | CommandExecutor | R2
+  Client.SqlClient | R2
 > = Migrator.make({
-  dumpSchema(path, table) {
-    const mysqlDump = (args: Array<string>) =>
-      Effect.gen(function*() {
-        const sql = yield* MysqlClient
-
-        const url = sql.config.url ? new URL(Redacted.value(sql.config.url)) : undefined
-
-        const host = url?.hostname ?? sql.config.host
-        const port = url?.port ?? sql.config.port?.toString()
-        const username = url?.username ?? sql.config.username
-        const password = url?.password ? Redacted.make(url.password) : sql.config.password
-        const database = url?.pathname?.slice(1) ?? sql.config.database
-
-        const dump = yield* pipe(
-          Command.make(
-            "mysqldump",
-            ...(host ? ["-h", host] : []),
-            ...(port ? ["-P", port] : []),
-            ...(username ? ["-u", username] : []),
-            ...(password ? [`-p${Redacted.value(password)}`] : []),
-            ...(database ? [database] : []),
-            "--skip-comments",
-            "--compact",
-            ...args
-          ),
-          Command.env({
-            PATH: (globalThis as any).process?.env.PATH
-          }),
-          Command.string
-        )
-
-        return dump.replace(/^\/\*.*$/gm, "")
-          .replace(/\n{2,}/gm, "\n\n")
-          .trim();
-      }).pipe(
-        Effect.mapError((error) => new Migrator.MigrationError({ reason: "failed", message: error.message }))
-      )
-
-    const dumpSchema = mysqlDump(["--no-data"])
-
-    const dumpMigrations = mysqlDump(["--no-create-info", "--tables", table])
-
-    const dumpAll = Effect.map(
-      Effect.all([dumpSchema, dumpMigrations], { concurrency: 2 }),
-      ([schema, migrations]) => schema + "\n\n" + migrations
-    )
-
-    const dumpFile = (file: string) =>
-      Effect.gen(function*() {
-        const fs = yield* FileSystem
-        const path = yield* Path
-        const dump = yield* dumpAll
-        yield* fs.makeDirectory(path.dirname(file), { recursive: true })
-        yield* fs.writeFileString(file, dump)
-      }).pipe(
-        Effect.mapError((error) => new Migrator.MigrationError({ reason: "failed", message: error.message }))
-      )
-
-    return dumpFile(path)
-  }
+  // TODO: re-add when Command module is available
+  // dumpSchema(path, table) {
+  //   const mysqlDump = (args: Array<string>) =>
+  //     Effect.gen(function*() {
+  //       const sql = yield* MysqlClient
+  //       const dump = yield* pipe(
+  //         Command.make(
+  //           "mysqldump",
+  //           ...(sql.config.host ? ["-h", sql.config.host] : []),
+  //           ...(sql.config.port ? ["-P", sql.config.port.toString()] : []),
+  //           ...(sql.config.username ? ["-u", sql.config.username] : []),
+  //           ...(sql.config.password ? [`-p${Redacted.value(sql.config.password)}`] : []),
+  //           ...(sql.config.database ? [sql.config.database] : []),
+  //           "--skip-comments",
+  //           "--compact",
+  //           ...args
+  //         ),
+  //         Command.env({
+  //           PATH: (globalThis as any).process?.env.PATH
+  //         }),
+  //         Command.string
+  //       )
+  //
+  //       return dump.replace(/^\/\*.*$/gm, "")
+  //         .replace(/\n{2,}/gm, "\n\n")
+  //         .trim()
+  //     }).pipe(
+  //       Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
+  //     )
+  //
+  //   const dumpSchema = mysqlDump(["--no-data"])
+  //
+  //   const dumpMigrations = mysqlDump(["--no-create-info", "--tables", table])
+  //
+  //   const dumpAll = Effect.map(
+  //     Effect.all([dumpSchema, dumpMigrations], { concurrency: 2 }),
+  //     ([schema, migrations]) => schema + "\n\n" + migrations
+  //   )
+  //
+  //   const dumpFile = (file: string) =>
+  //     Effect.gen(function*() {
+  //       const fs = yield* FileSystem
+  //       const path = yield* Path
+  //       const dump = yield* dumpAll
+  //       yield* fs.makeDirectory(path.dirname(file), { recursive: true })
+  //       yield* fs.writeFileString(file, dump)
+  //     }).pipe(
+  //       Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
+  //     )
+  //
+  //   return dumpFile(path)
+  // }
 })
 
 /**
@@ -106,5 +86,5 @@ export const layer = <R>(
 ): Layer.Layer<
   never,
   Migrator.MigrationError | SqlError,
-  MysqlClient | Client.SqlClient | CommandExecutor | FileSystem | Path | R
+  Client.SqlClient | R
 > => Layer.effectDiscard(run(options))

package/src/index.ts

@@ -1,9 +1,15 @@
 /**
  * @since 1.0.0
  */
-export * as MysqlClient from "./MysqlClient.js"
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @since 1.0.0
+ */
+export * as MysqlClient from "./MysqlClient.ts"
 
 /**
  * @since 1.0.0
  */
-export * as MysqlMigrator from "./MysqlMigrator.js"
+export * as MysqlMigrator from "./MysqlMigrator.ts"

package/MysqlClient/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/MysqlClient.js",
-  "module": "../dist/esm/MysqlClient.js",
-  "types": "../dist/dts/MysqlClient.d.ts"
-}

package/MysqlMigrator/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/MysqlMigrator.js",
-  "module": "../dist/esm/MysqlMigrator.js",
-  "types": "../dist/dts/MysqlMigrator.d.ts"
-}

package/dist/cjs/MysqlClient.js

@@ -1,223 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeCompiler = exports.make = exports.layerConfig = exports.layer = exports.TypeId = exports.MysqlClient = void 0;
-var Reactivity = _interopRequireWildcard(require("@effect/experimental/Reactivity"));
-var Client = _interopRequireWildcard(require("@effect/sql/SqlClient"));
-var _SqlError = require("@effect/sql/SqlError");
-var _SqlStream = require("@effect/sql/SqlStream");
-var Statement = _interopRequireWildcard(require("@effect/sql/Statement"));
-var Chunk = _interopRequireWildcard(require("effect/Chunk"));
-var Config = _interopRequireWildcard(require("effect/Config"));
-var Context = _interopRequireWildcard(require("effect/Context"));
-var Duration = _interopRequireWildcard(require("effect/Duration"));
-var Effect = _interopRequireWildcard(require("effect/Effect"));
-var Layer = _interopRequireWildcard(require("effect/Layer"));
-var Redacted = _interopRequireWildcard(require("effect/Redacted"));
-var Stream = _interopRequireWildcard(require("effect/Stream"));
-var Mysql = _interopRequireWildcard(require("mysql2"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-/**
- * @since 1.0.0
- */
-
-const ATTR_DB_SYSTEM_NAME = "db.system.name";
-const ATTR_DB_NAMESPACE = "db.namespace";
-const ATTR_SERVER_ADDRESS = "server.address";
-const ATTR_SERVER_PORT = "server.port";
-/**
- * @category type ids
- * @since 1.0.0
- */
-const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("@effect/sql-mysql2/MysqlClient");
-/**
- * @category tags
- * @since 1.0.0
- */
-const MysqlClient = exports.MysqlClient = /*#__PURE__*/Context.GenericTag("@effect/sql-mysql2/MysqlClient");
-/**
- * @category constructors
- * @since 1.0.0
- */
-const make = options => Effect.gen(function* () {
-  const compiler = makeCompiler(options.transformQueryNames);
-  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames).array : undefined;
-  class ConnectionImpl {
-    conn;
-    constructor(conn) {
-      this.conn = conn;
-    }
-    runRaw(sql, values, rowsAsArray = false, method = "execute") {
-      return Effect.async(resume => {
-        ;
-        this.conn[method]({
-          sql,
-          values,
-          rowsAsArray
-        }, (cause, results, _fields) => {
-          if (cause) {
-            resume(Effect.fail(new _SqlError.SqlError({
-              cause,
-              message: "Failed to execute statement"
-            })));
-          } else {
-            resume(Effect.succeed(results));
-          }
-        });
-      });
-    }
-    run(sql, values, rowsAsArray = false, method = "execute") {
-      return this.runRaw(sql, values, rowsAsArray, method).pipe(Effect.map(results => Array.isArray(results) ? results : []));
-    }
-    execute(sql, params, transformRows) {
-      return transformRows ? Effect.map(this.run(sql, params), transformRows) : this.run(sql, params);
-    }
-    executeRaw(sql, params) {
-      return this.runRaw(sql, params);
-    }
-    executeValues(sql, params) {
-      return this.run(sql, params, true);
-    }
-    executeUnprepared(sql, params, transformRows) {
-      return transformRows ? Effect.map(this.run(sql, params, false, "query"), transformRows) : this.run(sql, params, false, "query");
-    }
-    executeStream(sql, params, transformRows) {
-      const stream = queryStream(this.conn, sql, params);
-      return transformRows ? Stream.mapChunks(stream, _ => Chunk.unsafeFromArray(transformRows(Chunk.toReadonlyArray(_)))) : stream;
-    }
-  }
-  const pool = options.url ? Mysql.createPool({
-    uri: Redacted.value(options.url),
-    multipleStatements: true,
-    supportBigNumbers: true,
-    connectionLimit: options.maxConnections,
-    idleTimeout: options.connectionTTL ? Duration.toMillis(options.connectionTTL) : undefined
-  }) : Mysql.createPool({
-    ...(options.poolConfig ?? {}),
-    host: options.host,
-    port: options.port,
-    database: options.database,
-    user: options.username,
-    password: options.password ? Redacted.value(options.password) : undefined,
-    multipleStatements: true,
-    supportBigNumbers: true,
-    connectionLimit: options.maxConnections,
-    maxIdle: options.poolConfig?.maxIdle ?? 0,
-    idleTimeout: options.connectionTTL ? Duration.toMillis(options.connectionTTL) : undefined
-  });
-  yield* Effect.acquireRelease(Effect.async(resume => {
-    ;
-    pool.query("SELECT 1", cause => {
-      if (cause) {
-        resume(Effect.fail(new _SqlError.SqlError({
-          cause,
-          message: "MysqlClient: Failed to connect"
-        })));
-      } else {
-        resume(Effect.void);
-      }
-    });
-  }), () => Effect.async(resume => {
-    pool.end(() => resume(Effect.void));
-  })).pipe(Effect.timeoutFail({
-    duration: Duration.seconds(5),
-    onTimeout: () => new _SqlError.SqlError({
-      message: "MysqlClient: Connection timeout",
-      cause: new Error("connection timeout")
-    })
-  }));
-  const poolConnection = new ConnectionImpl(pool);
-  const acquireConn = Effect.acquireRelease(Effect.async(resume => {
-    pool.getConnection((cause, conn) => {
-      if (cause) {
-        resume(new _SqlError.SqlError({
-          cause,
-          message: "Failed to acquire connection"
-        }));
-      } else {
-        resume(Effect.succeed(conn));
-      }
-    });
-  }), conn => Effect.sync(() => conn.release()));
-  const transactionAcquirer = Effect.map(acquireConn, conn => new ConnectionImpl(conn));
-  const spanAttributes = [...(options.spanAttributes ? Object.entries(options.spanAttributes) : []), [ATTR_DB_SYSTEM_NAME, "mysql"], [ATTR_SERVER_ADDRESS, options.host ?? "localhost"], [ATTR_SERVER_PORT, options.port ?? 3306]];
-  if (options.database) {
-    spanAttributes.push([ATTR_DB_NAMESPACE, options.database]);
-  }
-  return Object.assign(yield* Client.make({
-    acquirer: Effect.succeed(poolConnection),
-    transactionAcquirer,
-    compiler,
-    spanAttributes,
-    transformRows
-  }), {
-    [TypeId]: TypeId,
-    config: options
-  });
-});
-/**
- * @category layers
- * @since 1.0.0
- */
-exports.make = make;
-const layerConfig = config => Layer.scopedContext(Config.unwrap(config).pipe(Effect.flatMap(make), Effect.map(client => Context.make(MysqlClient, client).pipe(Context.add(Client.SqlClient, client))))).pipe(Layer.provide(Reactivity.layer));
-/**
- * @category layers
- * @since 1.0.0
- */
-exports.layerConfig = layerConfig;
-const layer = config => Layer.scopedContext(Effect.map(make(config), client => Context.make(MysqlClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
-/**
- * @category compiler
- * @since 1.0.0
- */
-exports.layer = layer;
-const makeCompiler = transform => Statement.makeCompiler({
-  dialect: "mysql",
-  placeholder(_) {
-    return `?`;
-  },
-  onIdentifier: transform ? function (value, withoutTransform) {
-    return withoutTransform ? escape(value) : escape(transform(value));
-  } : escape,
-  onCustom() {
-    return ["", []];
-  },
-  onRecordUpdate() {
-    return ["", []];
-  }
-});
-exports.makeCompiler = makeCompiler;
-const escape = /*#__PURE__*/Statement.defaultEscape("`");
-function queryStream(conn, sql, params) {
-  return (0, _SqlStream.asyncPauseResume)(emit => {
-    const query = conn.query(sql, params).stream();
-    let buffer = [];
-    let taskPending = false;
-    query.on("error", cause => emit.fail(new _SqlError.SqlError({
-      cause,
-      message: "Failed to stream statement"
-    })));
-    query.on("data", row => {
-      buffer.push(row);
-      if (!taskPending) {
-        taskPending = true;
-        queueMicrotask(() => {
-          const items = buffer;
-          buffer = [];
-          emit.array(items);
-          taskPending = false;
-        });
-      }
-    });
-    query.on("end", () => emit.end());
-    return {
-      onInterrupt: Effect.sync(() => query.destroy()),
-      onPause: Effect.sync(() => query.pause()),
-      onResume: Effect.sync(() => query.resume())
-    };
-  });
-}
-//# sourceMappingURL=MysqlClient.js.map