envio 3.0.0-alpha.19 → 3.0.0-alpha.19-main-node-pg-client

package/src/db/InternalTable.res.mjs

@@ -26,7 +26,7 @@ var fields = [
   "_is_hyper_sync"
 ];
 
-var table = Table.mkTable("envio_chains", undefined, [
+var table = Table.mkTable("envio_chains", undefined, undefined, [
       Table.mkField("id", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
       Table.mkField("start_block", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("end_block", "Int32", S$RescriptSchema.$$null(S$RescriptSchema.$$int), undefined, undefined, true, undefined, undefined, undefined),
@@ -110,7 +110,11 @@ function makeGetInitialStateQuery(pgSchema) {
 }
 
 function getInitialState(sql, pgSchema) {
-  return sql.unsafe(makeGetInitialStateQuery(pgSchema));
+  return sql.query({
+                text: makeGetInitialStateQuery(pgSchema)
+              }).then(function (r) {
+              return r.rows;
+            });
 }
 
 var progressFields = [
@@ -137,7 +141,11 @@ function setMeta(sql, pgSchema, chainsData) {
                 var value = data[field];
                 params.push(value);
               });
-          promises.push(sql.unsafe(query, params, {prepare: true}));
+          promises.push(sql.query({
+                    text: query,
+                    values: params,
+                    name: "chains_set_meta"
+                  }));
         }));
   return Promise.all(promises);
 }
@@ -153,7 +161,11 @@ function setProgressedChains(sql, pgSchema, progressedChains) {
                       field === "progress_block" ? data.progressBlockNumber : data.totalEventsProcessed
                     ));
             });
-        promises.push(sql.unsafe(query, params, {prepare: true}));
+        promises.push(sql.query({
+                  text: query,
+                  values: params,
+                  name: "chains_set_progress"
+                }));
       });
   return Promise.all(promises);
 }
@@ -173,7 +185,7 @@ var Chains = {
   setProgressedChains: setProgressedChains
 };
 
-var table$1 = Table.mkTable("persisted_state", undefined, [
+var table$1 = Table.mkTable("persisted_state", undefined, undefined, [
       Table.mkField("id", "Serial", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
       Table.mkField("envio_version", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("config_hash", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
@@ -198,7 +210,7 @@ var dbSchema = S$RescriptSchema.object(function (s) {
             };
     });
 
-var table$2 = Table.mkTable("envio_checkpoints", undefined, [
+var table$2 = Table.mkTable("envio_checkpoints", undefined, undefined, [
       Table.mkField("id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, true, undefined, undefined),
       Table.mkField("chain_id", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("block_number", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
@@ -221,17 +233,25 @@ function makeInsertCheckpointQuery(pgSchema) {
 function insert(sql, pgSchema, checkpointIds, checkpointChainIds, checkpointBlockNumbers, checkpointBlockHashes, checkpointEventsProcessed) {
   var query = makeInsertCheckpointQuery(pgSchema);
   var checkpointIdStrings = $$BigInt.arrayToStringArray(checkpointIds);
-  return sql.unsafe(query, [
-              checkpointIdStrings,
-              checkpointChainIds,
-              checkpointBlockNumbers,
-              checkpointBlockHashes,
-              checkpointEventsProcessed
-            ], {prepare: true});
+  return sql.query({
+              text: query,
+              values: [
+                checkpointIdStrings,
+                checkpointChainIds,
+                checkpointBlockNumbers,
+                checkpointBlockHashes,
+                checkpointEventsProcessed
+              ],
+              name: "checkpoints_insert"
+            });
 }
 
 function rollback(sql, pgSchema, rollbackTargetCheckpointId) {
-  return sql.unsafe("DELETE FROM \"" + pgSchema + "\".\"" + table$2.tableName + "\" WHERE \"" + "id" + "\" > $1;", [rollbackTargetCheckpointId.toString()], {prepare: true});
+  return sql.query({
+              text: "DELETE FROM \"" + pgSchema + "\".\"" + table$2.tableName + "\" WHERE \"" + "id" + "\" > $1;",
+              values: [rollbackTargetCheckpointId.toString()],
+              name: "checkpoints_rollback"
+            });
 }
 
 function makePruneStaleCheckpointsQuery(pgSchema) {
@@ -239,7 +259,11 @@ function makePruneStaleCheckpointsQuery(pgSchema) {
 }
 
 function pruneStaleCheckpoints(sql, pgSchema, safeCheckpointId) {
-  return sql.unsafe(makePruneStaleCheckpointsQuery(pgSchema), [safeCheckpointId.toString()], {prepare: true});
+  return sql.query({
+              text: makePruneStaleCheckpointsQuery(pgSchema),
+              values: [safeCheckpointId.toString()],
+              name: "checkpoints_prune"
+            });
 }
 
 function makeGetRollbackTargetCheckpointQuery(pgSchema) {
@@ -247,11 +271,15 @@ function makeGetRollbackTargetCheckpointQuery(pgSchema) {
 }
 
 function getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValidBlockNumber) {
-  var rawResult = sql.unsafe(makeGetRollbackTargetCheckpointQuery(pgSchema), [
-        reorgChainId,
-        lastKnownValidBlockNumber
-      ], {prepare: true});
-  return rawResult.then(function (rows) {
+  return sql.query({
+                text: makeGetRollbackTargetCheckpointQuery(pgSchema),
+                values: [
+                  reorgChainId,
+                  lastKnownValidBlockNumber
+                ],
+                name: "checkpoints_rollback_target"
+              }).then(function (r) {
+              var rows = r.rows;
               return Belt_Option.map(Belt_Array.get(rows, 0), (function (row) {
                             return BigInt(row.id);
                           }));
@@ -259,11 +287,17 @@ function getRollbackTargetCheckpoint(sql, pgSchema, reorgChainId, lastKnownValid
 }
 
 function makeGetRollbackProgressDiffQuery(pgSchema) {
-  return "SELECT \n  \"" + "chain_id" + "\",\n  SUM(\"" + "events_processed" + "\") as events_processed_diff,\n  MIN(\"" + "block_number" + "\") - 1 as new_progress_block_number\nFROM \"" + pgSchema + "\".\"" + table$2.tableName + "\"\nWHERE \"" + "id" + "\" > $1\nGROUP BY \"" + "chain_id" + "\";";
+  return "SELECT\n  \"" + "chain_id" + "\",\n  SUM(\"" + "events_processed" + "\") as events_processed_diff,\n  MIN(\"" + "block_number" + "\") - 1 as new_progress_block_number\nFROM \"" + pgSchema + "\".\"" + table$2.tableName + "\"\nWHERE \"" + "id" + "\" > $1\nGROUP BY \"" + "chain_id" + "\";";
 }
 
 function getRollbackProgressDiff(sql, pgSchema, rollbackTargetCheckpointId) {
-  return sql.unsafe(makeGetRollbackProgressDiffQuery(pgSchema), [rollbackTargetCheckpointId.toString()], {prepare: true});
+  return sql.query({
+                text: makeGetRollbackProgressDiffQuery(pgSchema),
+                values: [rollbackTargetCheckpointId.toString()],
+                name: "checkpoints_rollback_diff"
+              }).then(function (r) {
+              return r.rows;
+            });
 }
 
 var Checkpoints = {
@@ -300,7 +334,7 @@ var schema = S$RescriptSchema.schema(function (s) {
             };
     });
 
-var table$3 = Table.mkTable("raw_events", undefined, [
+var table$3 = Table.mkTable("raw_events", undefined, undefined, [
       Table.mkField("chain_id", "Int32", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("event_id", "UInt64", S$RescriptSchema.bigint, undefined, undefined, undefined, undefined, undefined, undefined),
       Table.mkField("event_name", "String", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),

package/src/db/Table.res

@@ -109,43 +109,42 @@ let getPgFieldType = (
   ~pgSchema,
   ~isArray,
   ~isNumericArrayAsText,
-  ~isNullable,
+  ~isNullable as _,
 ) => {
   let columnType = switch fieldType {
-  | String => (Postgres.Text :> string)
-  | Boolean => (Postgres.Boolean :> string)
-  | Int32 => (Postgres.Integer :> string)
-  | Uint32 => (Postgres.BigInt :> string)
-  | UInt52 => (Postgres.BigInt :> string)
-  | UInt64 => (Postgres.BigInt :> string)
-  | Number => (Postgres.DoublePrecision :> string)
+  | String => (Pg.Text :> string)
+  | Boolean => (Pg.Boolean :> string)
+  | Int32 => (Pg.Integer :> string)
+  | Uint32 => (Pg.BigInt :> string)
+  | UInt52 => (Pg.BigInt :> string)
+  | UInt64 => (Pg.BigInt :> string)
+  | Number => (Pg.DoublePrecision :> string)
   | BigInt({?precision}) =>
-    (Postgres.Numeric :> string) ++
+    (Pg.Numeric :> string) ++
     switch precision {
     | Some(precision) => `(${precision->Int.toString}, 0)` // scale is always 0 for BigInt
     | None => ""
     }
 
   | BigDecimal({?config}) =>
-    (Postgres.Numeric :> string) ++
+    (Pg.Numeric :> string) ++
     switch config {
     | Some((precision, scale)) => `(${precision->Int.toString}, ${scale->Int.toString})`
     | None => ""
     }
 
-  | Serial => (Postgres.Serial :> string)
-  | BigSerial => (Postgres.BigSerial :> string)
-  | Json => (Postgres.JsonB :> string)
-  | Date =>
-    (isNullable ? Postgres.TimestampWithTimezoneNull : Postgres.TimestampWithTimezone :> string)
+  | Serial => (Pg.Serial :> string)
+  | BigSerial => (Pg.BigSerial :> string)
+  | Json => (Pg.JsonB :> string)
+  | Date => (Pg.TimestampWithTimezone :> string)
   | Enum({config}) => `"${pgSchema}".${config.name}`
-  | Entity(_) => (Postgres.Text :> string) // FIXME: Will it work correctly if id is not a text column?
+  | Entity(_) => (Pg.Text :> string) // FIXME: Will it work correctly if id is not a text column?
   }
 
   // Workaround for Hasura bug https://github.com/enviodev/hyperindex/issues/788
   let isNumericAsText = isArray && isNumericArrayAsText
-  let columnType = if columnType == (Postgres.Numeric :> string) && isNumericAsText {
-    (Postgres.Text :> string)
+  let columnType = if columnType == (Pg.Numeric :> string) && isNumericAsText {
+    (Pg.Text :> string)
   } else {
     columnType
   }
@@ -162,12 +161,17 @@ type compositeIndexField = {
 
 type table = {
   tableName: string,
+  stmtId: string,
   fields: array<fieldOrDerived>,
   compositeIndices: array<array<compositeIndexField>>,
 }
 
-let mkTable = (tableName, ~compositeIndices=[], ~fields) => {
+let mkTable = (tableName, ~stmtId=?, ~compositeIndices=[], ~fields) => {
   tableName,
+  stmtId: switch stmtId {
+  | Some(id) => id
+  | None => tableName
+  },
   fields,
   compositeIndices,
 }
@@ -257,6 +261,7 @@ type sqlParams<'entity> = {
   quotedNonPrimaryFieldNames: array<string>,
   arrayFieldTypes: array<string>,
   hasArrayField: bool,
+  jsonFieldIndices: array<int>,
 }
 
 let toSqlParams = (table: table, ~schema, ~pgSchema) => {
@@ -264,6 +269,8 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
   let quotedNonPrimaryFieldNames = []
   let arrayFieldTypes = []
   let hasArrayField = ref(false)
+  let jsonFieldIndices = []
+  let fieldIndex = ref(0)
 
   let dbSchema: S.t<Js.Dict.t<unknown>> = S.schema(s =>
     switch schema->S.classify {
@@ -280,16 +287,7 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
               hasArrayField := true
               S.array(child->coerceSchema)->S.toUnknown
             }
-          | JSON(_) => {
-              hasArrayField := true
-              schema
-            }
-          | Bool =>
-            // Workaround for https://github.com/porsager/postgres/issues/471
-            S.union([
-              S.literal(1)->S.shape(_ => true),
-              S.literal(0)->S.shape(_ => false),
-            ])->S.toUnknown
+          | JSON(_) => schema
           | _ => schema
           }
 
@@ -298,6 +296,19 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
         | None => raise(NonExistingTableField(location))
         }
 
+        // pg driver doesn't auto-serialize JSONB values like postgres.js did.
+        // Track JSON field indices for post-hoc serialization in PgStorage.
+        // For JSON fields, use S.unknown in dbSchema to avoid S.unnest+S.compile issues
+        // with complex schema types, and handle serialization externally.
+        let coercedSchema = switch field {
+        | Field({fieldType: Json}) => {
+            jsonFieldIndices->Js.Array2.push(fieldIndex.contents)->ignore
+            S.unknown
+          }
+        | _ => schema->coerceSchema
+        }
+        fieldIndex := fieldIndex.contents + 1
+
         quotedFieldNames
         ->Js.Array2.push(inlinedLocation)
         ->ignore
@@ -321,15 +332,15 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
               ~isNumericArrayAsText=false, // TODO: Test whether it should be passed via args and match the column type
             )
             switch f.fieldType {
-            | Enum(_) => `${(Text: Postgres.columnType :> string)}[]::${pgFieldType}`
-            | Boolean => `${(Integer: Postgres.columnType :> string)}[]::${pgFieldType}`
+            | Enum(_) => `${(Text: Pg.columnType :> string)}[]::${pgFieldType}`
+            | Boolean => pgFieldType
             | _ => pgFieldType
             }
-          | DerivedFrom(_) => (Text: Postgres.columnType :> string) ++ "[]"
+          | DerivedFrom(_) => (Text: Pg.columnType :> string) ++ "[]"
           },
         )
         ->ignore
-        dict->Js.Dict.set(location, s.matches(schema->coerceSchema))
+        dict->Js.Dict.set(location, s.matches(coercedSchema))
       })
       dict
     | _ => Js.Exn.raiseError("Failed creating db schema. Expected an object schema for table")
@@ -342,6 +353,7 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
     quotedNonPrimaryFieldNames,
     arrayFieldTypes,
     hasArrayField: hasArrayField.contents,
+    jsonFieldIndices,
   }
 }
 

package/src/db/Table.res.mjs

@@ -73,7 +73,7 @@ function getFieldName(fieldOrDerived) {
   }
 }
 
-function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNullable) {
+function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, param) {
   var columnType;
   if (typeof fieldType !== "object") {
     switch (fieldType) {
@@ -99,7 +99,7 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
           columnType = "JSONB";
           break;
       case "Date" :
-          columnType = isNullable ? "TIMESTAMP WITH TIME ZONE NULL" : "TIMESTAMP WITH TIME ZONE";
+          columnType = "TIMESTAMP WITH TIME ZONE";
           break;
       default:
         columnType = "BIGINT";
@@ -134,10 +134,11 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
         );
 }
 
-function mkTable(tableName, compositeIndicesOpt, fields) {
+function mkTable(tableName, stmtId, compositeIndicesOpt, fields) {
   var compositeIndices = compositeIndicesOpt !== undefined ? compositeIndicesOpt : [];
   return {
           tableName: tableName,
+          stmtId: stmtId !== undefined ? stmtId : tableName,
           fields: fields,
           compositeIndices: compositeIndices
         };
@@ -258,6 +259,10 @@ function toSqlParams(table, schema, pgSchema) {
   var hasArrayField = {
     contents: false
   };
+  var jsonFieldIndices = [];
+  var fieldIndex = {
+    contents: 0
+  };
   var dbSchema = S$RescriptSchema.schema(function (s) {
         var match = schema.t;
         if (typeof match !== "object") {
@@ -270,39 +275,26 @@ function toSqlParams(table, schema, pgSchema) {
         Belt_Array.forEach(match.items, (function (param) {
                 var inlinedLocation = param.inlinedLocation;
                 var $$location = param.location;
+                var schema = param.schema;
                 var coerceSchema = function (schema) {
                   var child = schema.t;
                   if (typeof child !== "object") {
-                    switch (child) {
-                      case "bigint" :
-                          return $$BigInt.schema;
-                      case "boolean" :
-                          return S$RescriptSchema.union([
-                                      S$RescriptSchema.shape(S$RescriptSchema.literal(1), (function (param) {
-                                              return true;
-                                            })),
-                                      S$RescriptSchema.shape(S$RescriptSchema.literal(0), (function (param) {
-                                              return false;
-                                            }))
-                                    ]);
-                      default:
-                        return schema;
-                    }
-                  } else {
-                    switch (child.TAG) {
-                      case "option" :
-                      case "null" :
-                          return S$RescriptSchema.$$null(coerceSchema(child._0));
-                      case "array" :
-                          hasArrayField.contents = true;
-                          return S$RescriptSchema.array(coerceSchema(child._0));
-                      case "JSON" :
-                          hasArrayField.contents = true;
-                          return schema;
-                      default:
-                        return schema;
+                    if (child === "bigint") {
+                      return $$BigInt.schema;
+                    } else {
+                      return schema;
                     }
                   }
+                  switch (child.TAG) {
+                    case "option" :
+                    case "null" :
+                        return S$RescriptSchema.$$null(coerceSchema(child._0));
+                    case "array" :
+                        hasArrayField.contents = true;
+                        return S$RescriptSchema.array(coerceSchema(child._0));
+                    default:
+                      return schema;
+                  }
                 };
                 var field = getFieldByDbName(table, $$location);
                 var field$1;
@@ -315,6 +307,19 @@ function toSqlParams(table, schema, pgSchema) {
                         Error: new Error()
                       };
                 }
+                var coercedSchema;
+                if (field$1.TAG === "Field") {
+                  var tmp = field$1._0.fieldType;
+                  if (typeof tmp !== "object" && tmp === "Json") {
+                    jsonFieldIndices.push(fieldIndex.contents);
+                    coercedSchema = S$RescriptSchema.unknown;
+                  } else {
+                    coercedSchema = coerceSchema(schema);
+                  }
+                } else {
+                  coercedSchema = coerceSchema(schema);
+                }
+                fieldIndex.contents = fieldIndex.contents + 1 | 0;
                 quotedFieldNames.push(inlinedLocation);
                 if (field$1.TAG === "Field") {
                   if (field$1._0.isPrimaryKey) {
@@ -323,21 +328,17 @@ function toSqlParams(table, schema, pgSchema) {
                     quotedNonPrimaryFieldNames.push(inlinedLocation);
                   }
                 }
-                var tmp;
+                var tmp$1;
                 if (field$1.TAG === "Field") {
                   var f = field$1._0;
                   var pgFieldType = getPgFieldType(f.fieldType, pgSchema, true, false, f.isNullable);
                   var match = f.fieldType;
-                  tmp = typeof match !== "object" ? (
-                      match === "Boolean" ? "INTEGER[]::" + pgFieldType : pgFieldType
-                    ) : (
-                      match.type === "Enum" ? "TEXT[]::" + pgFieldType : pgFieldType
-                    );
+                  tmp$1 = typeof match !== "object" || match.type !== "Enum" ? pgFieldType : "TEXT[]::" + pgFieldType;
                 } else {
-                  tmp = "TEXT[]";
+                  tmp$1 = "TEXT[]";
                 }
-                arrayFieldTypes.push(tmp);
-                dict[$$location] = s.m(coerceSchema(param.schema));
+                arrayFieldTypes.push(tmp$1);
+                dict[$$location] = s.m(coercedSchema);
               }));
         return dict;
       });
@@ -346,7 +347,8 @@ function toSqlParams(table, schema, pgSchema) {
           quotedFieldNames: quotedFieldNames,
           quotedNonPrimaryFieldNames: quotedNonPrimaryFieldNames,
           arrayFieldTypes: arrayFieldTypes,
-          hasArrayField: hasArrayField.contents
+          hasArrayField: hasArrayField.contents,
+          jsonFieldIndices: jsonFieldIndices
         };
 }
 

package/src/PgStorage.gen.ts

@@ -1,10 +0,0 @@
-/* TypeScript file generated from PgStorage.res by genType. */
-
-/* eslint-disable */
-/* tslint:disable */
-
-import * as PgStorageJS from './PgStorage.res.mjs';
-
-import type {sql as Postgres_sql} from '../src/bindings/Postgres.gen.js';
-
-export const makeClient: () => Postgres_sql = PgStorageJS.makeClient as any;

package/src/bindings/Postgres.gen.ts

@@ -1,8 +0,0 @@
-/* TypeScript file generated from Postgres.res by genType. */
-
-/* eslint-disable */
-/* tslint:disable */
-
-import type {Sql as $$sql} from 'postgres';
-
-export type sql = $$sql;

package/src/bindings/Postgres.res

@@ -1,120 +0,0 @@
-// Only needed for some old tests
-// Remove @genType in the future
-@genType.import(("postgres", "Sql"))
-type sql
-
-type undefinedTransform = | @as(undefined) Undefined | @as(null) Null
-
-type transformConfig = {
-  undefined?: undefinedTransform, // Transforms undefined values (eg. to null) (default: undefined)
-  // column?: 'c => 'd, // Transforms incoming column names (default: fn)
-  // value?: 'e => 'f, // Transforms incoming row values (default: fn)
-  // row?: 'g => 'h, // Transforms entire rows (default: fn)
-}
-
-type connectionConfig = {
-  applicationName?: string, // Default application_name (default: 'postgres.js')
-  // Other connection parameters, see https://www.postgresql.org/docs/current/runtime-config-client.html
-}
-type streamDuplex
-type buffer
-type secureContext
-
-type onread = {
-  buffer: Js.Nullable.t<array<int>> => array<int>,
-  callback: (int, array<int>) => unit,
-}
-
-type tlsConnectOptions = {
-  enableTrace?: bool,
-  host?: string /* Default: "localhost" */,
-  port?: int,
-  path?: string,
-  socket?: streamDuplex,
-  allowHalfOpen?: bool /* Default: false */,
-  rejectUnauthorized?: bool /* Default: true */,
-  pskCallback?: unit => unit,
-  @as("ALPNProtocols") alpnProtocols?: array<string>, //| array<Buffer> | array<typedArray> | array<DataView> | Buffer | typedArray | DataView,
-  servername?: string,
-  checkServerIdentity?: 'a. (string, 'a) => option<Js.Exn.t>,
-  session?: buffer,
-  minDHSize?: int /* Default: 1024 */,
-  highWaterMark?: int /* Default: 16 * 1024 */,
-  secureContext?: secureContext,
-  onread?: onread,
-  /* Additional properties from tls.createSecureContext() and socket.connect() */
-  // [key: string]: Js.Json.t,
-}
-
-@unboxed
-type sslOptions =
-  | Bool(bool)
-  | TLSConnectOptions(tlsConnectOptions)
-  | @as("require") Require
-  | @as("allow") Allow
-  | @as("prefer") Prefer
-  | @as("verify-full") VerifyFull
-
-let sslOptionsSchema: S.schema<sslOptions> = S.enum([
-  Bool(true),
-  Bool(false),
-  Require,
-  Allow,
-  Prefer,
-  VerifyFull,
-  //No schema created for tlsConnectOptions obj
-])
-
-type poolConfig = {
-  host?: string, // Postgres ip address[es] or domain name[s] (default: '')
-  port?: int, // Postgres server port[s] (default: 5432)
-  path?: string, // unix socket path (usually '/tmp') (default: '')
-  database?: string, // Name of database to connect to (default: '')
-  username?: string, // Username of database user (default: '')
-  password?: string, // Password of database user (default: '')
-  ssl?: sslOptions, // true, prefer, require, tls.connect options (default: false)
-  max?: int, // Max number of connections (default: 10)
-  maxLifetime?: option<int>, // Max lifetime in seconds (more info below) (default: null)
-  idleTimeout?: int, // Idle connection timeout in seconds (default: 0)
-  connectTimeout?: int, // Connect timeout in seconds (default: 30)
-  prepare?: bool, // Automatic creation of prepared statements (default: true)
-  onnotice?: string => unit, // Default console.log, set false to silence NOTICE (default: fn)
-  onParameter?: (string, string) => unit, // (key, value) when server param change (default: fn)
-  debug?: (~connection: unknown, ~query: unknown, ~params: unknown, ~types: unknown) => unit, // Is called with (connection, query, params, types)
-  socket?: unit => unit, // fn returning custom socket to use (default: fn)
-  transform?: transformConfig,
-  connection?: connectionConfig,
-  targetSessionAttrs?: option<string>, // Use 'read-write' with multiple hosts to ensure only connecting to primary (default: null)
-  fetchTypes?: bool, // Automatically fetches types on connect on initial connection. (default: true)
-}
-
-@module("postgres")
-external makeSql: (~config: poolConfig) => sql = "default"
-
-@send external beginSql: (sql, sql => promise<'result>) => promise<'result> = "begin"
-
-// TODO: can explore this approach (https://forum.rescript-lang.org/t/rfc-support-for-tagged-template-literals/3744)
-// @send @variadic
-// external sql:  array<string>  => (sql, array<string>) => int = "sql"
-
-@send external unsafe: (sql, string) => promise<'a> = "unsafe"
-@send external unpreparedUnsafe: (sql, string, unknown) => promise<'a> = "unsafe"
-@send
-external preparedUnsafe: (sql, string, unknown, @as(json`{prepare: true}`) _) => promise<'a> =
-  "unsafe"
-
-@unboxed
-type columnType =
-  | @as("INTEGER") Integer
-  | @as("BIGINT") BigInt
-  | @as("BOOLEAN") Boolean
-  | @as("NUMERIC") Numeric
-  | @as("DOUBLE PRECISION") DoublePrecision
-  | @as("TEXT") Text
-  | @as("SERIAL") Serial
-  | @as("BIGSERIAL") BigSerial
-  | @as("JSONB") JsonB
-  | @as("TIMESTAMP WITH TIME ZONE") TimestampWithTimezone
-  | @as("TIMESTAMP WITH TIME ZONE NULL") TimestampWithTimezoneNull
-  | @as("TIMESTAMP") TimestampWithoutTimezone
-  | Custom(string)

package/src/bindings/Postgres.res.mjs

@@ -1,17 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-
-var sslOptionsSchema = S$RescriptSchema.$$enum([
-      true,
-      false,
-      "require",
-      "allow",
-      "prefer",
-      "verify-full"
-    ]);
-
-export {
-  sslOptionsSchema ,
-}
-/* sslOptionsSchema Not a pure module */