@effect/sql-pg 0.50.3 → 4.0.0-beta.0

package/src/PgMigrator.ts

@@ -1,28 +1,16 @@
 /**
  * @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 { PgClient } from "./PgClient.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
@@ -33,63 +21,64 @@ export const run: <R2 = never>(
 ) => Effect.Effect<
   ReadonlyArray<readonly [id: number, name: string]>,
   Migrator.MigrationError | SqlError,
-  FileSystem | Path | PgClient | Client.SqlClient | CommandExecutor | R2
+  Client.SqlClient | R2
 > = Migrator.make({
-  dumpSchema(path, table) {
-    const pgDump = (args: Array<string>) =>
-      Effect.gen(function*() {
-        const sql = yield* PgClient
-        const dump = yield* pipe(
-          Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"),
-          Command.env({
-            PATH: (globalThis as any).process?.env.PATH,
-            PGHOST: sql.config.host,
-            PGPORT: sql.config.port?.toString(),
-            PGUSER: sql.config.username,
-            PGPASSWORD: sql.config.password
-              ? Redacted.value(sql.config.password)
-              : undefined,
-            PGDATABASE: sql.config.database,
-            PGSSLMODE: sql.config.ssl ? "require" : "prefer"
-          }),
-          Command.string
-        )
-
-        return dump.replace(/^--.*$/gm, "")
-          .replace(/^SET .*$/gm, "")
-          .replace(/^SELECT pg_catalog\..*$/gm, "")
-          .replace(/\n{2,}/gm, "\n\n")
-          .trim();
-      }).pipe(
-        Effect.mapError((error) => new Migrator.MigrationError({ reason: "failed", message: error.message }))
-      )
-
-    const pgDumpSchema = pgDump(["--schema-only"])
-
-    const pgDumpMigrations = pgDump([
-      "--column-inserts",
-      "--data-only",
-      `--table=${table}`
-    ])
-
-    const pgDumpAll = Effect.map(
-      Effect.all([pgDumpSchema, pgDumpMigrations], { concurrency: 2 }),
-      ([schema, migrations]) => schema + "\n\n" + migrations
-    )
-
-    const pgDumpFile = (path: string) =>
-      Effect.gen(function*() {
-        const fs = yield* FileSystem
-        const path_ = yield* Path
-        const dump = yield* pgDumpAll
-        yield* fs.makeDirectory(path_.dirname(path), { recursive: true })
-        yield* fs.writeFileString(path, dump)
-      }).pipe(
-        Effect.mapError((error) => new Migrator.MigrationError({ reason: "failed", message: error.message }))
-      )
-
-    return pgDumpFile(path)
-  }
+  // TODO: Wait for Command module
+  // dumpSchema(path, table) {
+  //   const pgDump = (args: Array<string>) =>
+  //     Effect.gen(function*() {
+  //       const sql = yield* PgClient
+  //       const dump = yield* pipe(
+  //         Command.make("pg_dump", ...args, "--no-owner", "--no-privileges"),
+  //         Command.env({
+  //           PATH: (globalThis as any).process?.env.PATH,
+  //           PGHOST: sql.config.host,
+  //           PGPORT: sql.config.port?.toString(),
+  //           PGUSER: sql.config.username,
+  //           PGPASSWORD: sql.config.password
+  //             ? Redacted.value(sql.config.password)
+  //             : undefined,
+  //           PGDATABASE: sql.config.database,
+  //           PGSSLMODE: sql.config.ssl ? "require" : "prefer"
+  //         }),
+  //         Command.string
+  //       )
+  //
+  //       return dump.replace(/^--.*$/gm, "")
+  //         .replace(/^SET .*$/gm, "")
+  //         .replace(/^SELECT pg_catalog\..*$/gm, "")
+  //         .replace(/\n{2,}/gm, "\n\n")
+  //         .trim()
+  //     }).pipe(
+  //       Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
+  //     )
+  //
+  //   const pgDumpSchema = pgDump(["--schema-only"])
+  //
+  //   const pgDumpMigrations = pgDump([
+  //     "--column-inserts",
+  //     "--data-only",
+  //     `--table=${table}`
+  //   ])
+  //
+  //   const pgDumpAll = Effect.map(
+  //     Effect.all([pgDumpSchema, pgDumpMigrations], { concurrency: 2 }),
+  //     ([schema, migrations]) => schema + "\n\n" + migrations
+  //   )
+  //
+  //   const pgDumpFile = (path: string) =>
+  //     Effect.gen(function*() {
+  //       const fs = yield* FileSystem
+  //       const path_ = yield* Path
+  //       const dump = yield* pgDumpAll
+  //       yield* fs.makeDirectory(path_.dirname(path), { recursive: true })
+  //       yield* fs.writeFileString(path, dump)
+  //     }).pipe(
+  //       Effect.mapError((error) => new Migrator.MigrationError({ kind: "Failed", message: error.message }))
+  //     )
+  //
+  //   return pgDumpFile(path)
+  // }
 })
 
 /**
@@ -101,5 +90,5 @@ export const layer = <R>(
 ): Layer.Layer<
   never,
   Migrator.MigrationError | SqlError,
-  PgClient | 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 PgClient from "./PgClient.js"
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @since 1.0.0
+ */
+export * as PgClient from "./PgClient.ts"
 
 /**
  * @since 1.0.0
  */
-export * as PgMigrator from "./PgMigrator.js"
+export * as PgMigrator from "./PgMigrator.ts"

package/PgClient/package.json

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

package/PgMigrator/package.json

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

package/dist/cjs/PgClient.js

@@ -1,434 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeCompiler = exports.make = exports.layerFromPool = exports.layerConfig = exports.layer = exports.fromPool = exports.TypeId = exports.PgClient = void 0;
-var Reactivity = _interopRequireWildcard(require("@effect/experimental/Reactivity"));
-var Client = _interopRequireWildcard(require("@effect/sql/SqlClient"));
-var _SqlError = require("@effect/sql/SqlError");
-var Statement = _interopRequireWildcard(require("@effect/sql/Statement"));
-var Arr = _interopRequireWildcard(require("effect/Array"));
-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 Fiber = _interopRequireWildcard(require("effect/Fiber"));
-var Layer = _interopRequireWildcard(require("effect/Layer"));
-var Number = _interopRequireWildcard(require("effect/Number"));
-var Option = _interopRequireWildcard(require("effect/Option"));
-var RcRef = _interopRequireWildcard(require("effect/RcRef"));
-var Redacted = _interopRequireWildcard(require("effect/Redacted"));
-var Scope = _interopRequireWildcard(require("effect/Scope"));
-var Stream = _interopRequireWildcard(require("effect/Stream"));
-var Pg = _interopRequireWildcard(require("pg"));
-var PgConnString = _interopRequireWildcard(require("pg-connection-string"));
-var _pgCursor = _interopRequireDefault(require("pg-cursor"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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 = "~@effect/sql-pg/PgClient";
-/**
- * @category tags
- * @since 1.0.0
- */
-const PgClient = exports.PgClient = /*#__PURE__*/Context.GenericTag("@effect/sql-pg/PgClient");
-const makeClient = (pool, config, options) => Effect.gen(function* () {
-  const compiler = makeCompiler(options.transformQueryNames, options.transformJson);
-  const transformRows = options.transformResultNames ? Statement.defaultTransforms(options.transformResultNames, options.transformJson).array : undefined;
-  class ConnectionImpl {
-    pg;
-    constructor(pg) {
-      this.pg = pg;
-    }
-    runWithClient(f) {
-      if (this.pg !== undefined) {
-        return Effect.async(resume => {
-          f(this.pg, resume);
-          return makeCancel(pool, this.pg);
-        });
-      }
-      return Effect.async(resume => {
-        let done = false;
-        let cancel = undefined;
-        let client = undefined;
-        function onError(cause) {
-          cleanup(cause);
-          resume(Effect.fail(new _SqlError.SqlError({
-            cause,
-            message: "Connection error"
-          })));
-        }
-        function cleanup(cause) {
-          if (!done) client?.release(cause);
-          done = true;
-          client?.off("error", onError);
-        }
-        pool.connect((cause, client_) => {
-          if (cause) {
-            return resume(Effect.fail(new _SqlError.SqlError({
-              cause,
-              message: "Failed to acquire connection"
-            })));
-          } else if (!client_) {
-            return resume(Effect.fail(new _SqlError.SqlError({
-              message: "Failed to acquire connection",
-              cause: new Error("No client returned")
-            })));
-          } else if (done) {
-            client_.release();
-            return;
-          }
-          client = client_;
-          client.once("error", onError);
-          cancel = makeCancel(pool, client);
-          f(client, eff => {
-            cleanup();
-            resume(eff);
-          });
-        });
-        return Effect.suspend(() => {
-          if (!cancel) {
-            cleanup();
-            return Effect.void;
-          }
-          return Effect.ensuring(cancel, Effect.sync(cleanup));
-        });
-      });
-    }
-    run(query, params) {
-      return this.runWithClient((client, resume) => {
-        client.query(query, params, (err, result) => {
-          if (err) {
-            resume(Effect.fail(new _SqlError.SqlError({
-              cause: err,
-              message: "Failed to execute statement"
-            })));
-          } else {
-            // Multi-statement queries return an array of results
-            resume(Effect.succeed(Array.isArray(result) ? result.map(r => r.rows ?? []) : result.rows ?? []));
-          }
-        });
-      });
-    }
-    execute(sql, params, transformRows) {
-      return transformRows ? Effect.map(this.run(sql, params), transformRows) : this.run(sql, params);
-    }
-    executeRaw(sql, params) {
-      return this.runWithClient((client, resume) => {
-        client.query(sql, params, (err, result) => {
-          if (err) {
-            resume(Effect.fail(new _SqlError.SqlError({
-              cause: err,
-              message: "Failed to execute statement"
-            })));
-          } else {
-            resume(Effect.succeed(result));
-          }
-        });
-      });
-    }
-    executeWithoutTransform(sql, params) {
-      return this.run(sql, params);
-    }
-    executeValues(sql, params) {
-      return this.runWithClient((client, resume) => {
-        client.query({
-          text: sql,
-          rowMode: "array",
-          values: params
-        }, (err, result) => {
-          if (err) {
-            resume(Effect.fail(new _SqlError.SqlError({
-              cause: err,
-              message: "Failed to execute statement"
-            })));
-          } else {
-            resume(Effect.succeed(result.rows));
-          }
-        });
-      });
-    }
-    executeUnprepared(sql, params, transformRows) {
-      return this.execute(sql, params, transformRows);
-    }
-    executeStream(sql, params, transformRows) {
-      // eslint-disable-next-line @typescript-eslint/no-this-alias
-      const self = this;
-      return Effect.gen(function* () {
-        const scope = yield* Effect.scope;
-        const client = self.pg ?? (yield* reserveRaw);
-        yield* Scope.addFinalizer(scope, Effect.promise(() => cursor.close()));
-        const cursor = client.query(new _pgCursor.default(sql, params));
-        const pull = Effect.async(resume => {
-          cursor.read(128, (err, rows) => {
-            if (err) {
-              resume(Effect.fail(Option.some(new _SqlError.SqlError({
-                cause: err,
-                message: "Failed to execute statement"
-              }))));
-            } else if (Arr.isNonEmptyArray(rows)) {
-              resume(Effect.succeed(Chunk.unsafeFromArray(transformRows ? transformRows(rows) : rows)));
-            } else {
-              resume(Effect.fail(Option.none()));
-            }
-          });
-        });
-        return Stream.repeatEffectChunkOption(pull);
-      }).pipe(Stream.unwrapScoped);
-    }
-  }
-  const reserveRaw = Effect.async(resume => {
-    const fiber = Option.getOrThrow(Fiber.getCurrentFiber());
-    const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope);
-    let cause = undefined;
-    function onError(cause_) {
-      cause = cause_;
-    }
-    pool.connect((err, client, release) => {
-      if (err) {
-        resume(Effect.fail(new _SqlError.SqlError({
-          cause: err,
-          message: "Failed to acquire connection for transaction"
-        })));
-        return;
-      } else if (!client) {
-        resume(Effect.fail(new _SqlError.SqlError({
-          message: "Failed to acquire connection for transaction",
-          cause: new Error("No client returned")
-        })));
-        return;
-      }
-      // Else we know we have client defined, so we can proceed with the connection
-      client.on("error", onError);
-      resume(Effect.as(Scope.addFinalizer(scope, Effect.sync(() => {
-        client.off("error", onError);
-        release(cause);
-      })), client));
-    });
-  });
-  const reserve = Effect.map(reserveRaw, client => new ConnectionImpl(client));
-  const listenClient = yield* RcRef.make({
-    acquire: reserveRaw
-  });
-  return Object.assign(yield* Client.make({
-    acquirer: Effect.succeed(new ConnectionImpl()),
-    transactionAcquirer: reserve,
-    compiler,
-    spanAttributes: [...(options.spanAttributes ? Object.entries(options.spanAttributes) : []), [ATTR_DB_SYSTEM_NAME, "postgresql"], [ATTR_DB_NAMESPACE, config.database ?? config.username ?? "postgres"], [ATTR_SERVER_ADDRESS, config.host ?? "localhost"], [ATTR_SERVER_PORT, config.port ?? 5432]],
-    transformRows
-  }), {
-    [TypeId]: TypeId,
-    config,
-    json: _ => PgJson(_),
-    listen: channel => Stream.asyncPush(Effect.fnUntraced(function* (emit) {
-      const client = yield* RcRef.get(listenClient);
-      function onNotification(msg) {
-        if (msg.channel === channel && msg.payload) {
-          emit.single(msg.payload);
-        }
-      }
-      yield* Effect.addFinalizer(() => Effect.promise(() => {
-        client.off("notification", onNotification);
-        return client.query(`UNLISTEN ${Pg.escapeIdentifier(channel)}`);
-      }));
-      yield* Effect.tryPromise({
-        try: () => client.query(`LISTEN ${Pg.escapeIdentifier(channel)}`),
-        catch: cause => new _SqlError.SqlError({
-          cause,
-          message: "Failed to listen"
-        })
-      });
-      client.on("notification", onNotification);
-    })),
-    notify: (channel, payload) => Effect.async(resume => {
-      pool.query(`NOTIFY ${Pg.escapeIdentifier(channel)}, $1`, [payload], err => {
-        if (err) {
-          resume(Effect.fail(new _SqlError.SqlError({
-            cause: err,
-            message: "Failed to notify"
-          })));
-        } else {
-          resume(Effect.void);
-        }
-      });
-    })
-  });
-});
-/**
- * @category constructors
- * @since 1.0.0
- */
-const make = options => Effect.gen(function* () {
-  const pool = new Pg.Pool({
-    connectionString: options.url ? Redacted.value(options.url) : undefined,
-    user: options.username,
-    host: options.host,
-    database: options.database,
-    password: options.password ? Redacted.value(options.password) : undefined,
-    ssl: options.ssl,
-    port: options.port,
-    ...(options.stream ? {
-      stream: options.stream
-    } : {}),
-    connectionTimeoutMillis: options.connectTimeout ? Duration.toMillis(options.connectTimeout) : undefined,
-    idleTimeoutMillis: options.idleTimeout ? Duration.toMillis(options.idleTimeout) : undefined,
-    max: options.maxConnections,
-    min: options.minConnections,
-    maxLifetimeSeconds: options.connectionTTL ? Duration.toSeconds(options.connectionTTL) : undefined,
-    application_name: options.applicationName ?? "@effect/sql-pg",
-    types: options.types
-  });
-  pool.on("error", _err => {});
-  yield* Effect.acquireRelease(Effect.tryPromise({
-    try: () => pool.query("SELECT 1"),
-    catch: cause => new _SqlError.SqlError({
-      cause,
-      message: "PgClient: Failed to connect"
-    })
-  }), () => Effect.promise(() => pool.end()).pipe(Effect.interruptible, Effect.timeoutOption(1000))).pipe(Effect.timeoutFail({
-    duration: options.connectTimeout ?? Duration.seconds(5),
-    onTimeout: () => new _SqlError.SqlError({
-      cause: new Error("Connection timed out"),
-      message: "PgClient: Connection timed out"
-    })
-  }));
-  let config = options;
-  if (pool.options.connectionString) {
-    try {
-      const parsed = PgConnString.parse(pool.options.connectionString);
-      config = {
-        ...config,
-        host: config.host ?? parsed.host ?? undefined,
-        port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
-        username: config.username ?? parsed.user ?? undefined,
-        password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
-        database: config.database ?? parsed.database ?? undefined
-      };
-    } catch {
-      //
-    }
-  }
-  return yield* makeClient(pool, config, options);
-});
-/**
- * Create a `PgClient` from an existing `pg` pool.
- *
- * You control the pool lifecycle via `acquire` (typically `Effect.acquireRelease`).
- *
- * @category constructors
- * @since 1.0.0
- */
-exports.make = make;
-const fromPool = exports.fromPool = /*#__PURE__*/Effect.fnUntraced(function* (options) {
-  const pool = yield* options.acquire;
-  let config = {
-    url: pool.options.connectionString ? Redacted.make(pool.options.connectionString) : undefined,
-    host: pool.options.host,
-    port: pool.options.port,
-    database: pool.options.database,
-    username: pool.options.user,
-    password: typeof pool.options.password === "string" ? Redacted.make(pool.options.password) : undefined,
-    ssl: pool.options.ssl,
-    applicationName: pool.options.application_name,
-    types: pool.options.types
-  };
-  if (pool.options.connectionString) {
-    try {
-      const parsed = PgConnString.parse(pool.options.connectionString);
-      config = {
-        ...config,
-        host: config.host ?? parsed.host ?? undefined,
-        port: config.port ?? (parsed.port ? Option.getOrUndefined(Number.parse(parsed.port)) : undefined),
-        username: config.username ?? parsed.user ?? undefined,
-        password: config.password ?? (parsed.password ? Redacted.make(parsed.password) : undefined),
-        database: config.database ?? parsed.database ?? undefined
-      };
-    } catch {
-      //
-    }
-  }
-  return yield* makeClient(pool, config, options);
-});
-const cancelEffects = /*#__PURE__*/new WeakMap();
-const makeCancel = (pool, client) => {
-  if (cancelEffects.has(client)) {
-    return cancelEffects.get(client);
-  }
-  const processId = client.processID;
-  const eff = processId !== undefined
-  // query cancelation is best-effort, so we don't fail if it doesn't work
-  ? Effect.async(resume => {
-    if (pool.ending) return resume(Effect.void);
-    pool.query(`SELECT pg_cancel_backend(${processId})`, () => {
-      resume(Effect.void);
-    });
-  }).pipe(Effect.interruptible, Effect.timeoutOption(5000)) : undefined;
-  cancelEffects.set(client, eff);
-  return eff;
-};
-/**
- * @category layers
- * @since 1.0.0
- */
-const layerConfig = config => Layer.scopedContext(Config.unwrap(config).pipe(Effect.flatMap(make), Effect.map(client => Context.make(PgClient, 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(PgClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
-/**
- * @category layers
- * @since 1.0.0
- */
-exports.layer = layer;
-const layerFromPool = options => Layer.scopedContext(Effect.map(fromPool(options), client => Context.make(PgClient, client).pipe(Context.add(Client.SqlClient, client)))).pipe(Layer.provide(Reactivity.layer));
-/**
- * @category constructor
- * @since 1.0.0
- */
-exports.layerFromPool = layerFromPool;
-const makeCompiler = (transform, transformJson = true) => {
-  const transformValue = transformJson && transform ? Statement.defaultTransforms(transform).value : undefined;
-  return Statement.makeCompiler({
-    dialect: "pg",
-    placeholder(_) {
-      return `$${_}`;
-    },
-    onIdentifier: transform ? function (value, withoutTransform) {
-      return withoutTransform ? escape(value) : escape(transform(value));
-    } : escape,
-    onRecordUpdate(placeholders, valueAlias, valueColumns, values, returning) {
-      return [`(values ${placeholders}) AS ${valueAlias}${valueColumns}${returning ? ` RETURNING ${returning[0]}` : ""}`, returning ? values.flat().concat(returning[1]) : values.flat()];
-    },
-    onCustom(type, placeholder, withoutTransform) {
-      switch (type.kind) {
-        case "PgJson":
-          {
-            return [placeholder(undefined), [withoutTransform || transformValue === undefined ? type.i0 : transformValue(type.i0)]];
-          }
-      }
-    }
-  });
-};
-exports.makeCompiler = makeCompiler;
-const escape = /*#__PURE__*/Statement.defaultEscape("\"");
-/**
- * @category custom types
- * @since 1.0.0
- */
-const PgJson = /*#__PURE__*/Statement.custom("PgJson");
-//# sourceMappingURL=PgClient.js.map